1
// SPDX-License-Identifier: MIT
2
3
pragma solidity ^0.8.6;
4
5
/**
6
* @dev External interface of AccessControl declared to support ERC165 detection.
7
*/
8
interface IAccessControl {
9
/**
10
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
11
*
12
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
13
* {RoleAdminChanged} not being emitted signaling this.
14
*
15
* _Available since v3.1._
16
*/
17
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
18
19
/**
20
* @dev Emitted when `account` is granted `role`.
21
*
22
* `sender` is the account that originated the contract call, an admin role
23
* bearer except when using {AccessControl-_setupRole}.
24
*/
25
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
26
27
/**
28
* @dev Emitted when `account` is revoked `role`.
29
*
30
* `sender` is the account that originated the contract call:
31
* - if using `revokeRole`, it is the admin role bearer
32
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
33
*/
34
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
35
36
/**
37
* @dev Returns `true` if `account` has been granted `role`.
38
*/
39
function hasRole(bytes32 role, address account) external view returns (bool);
40
41
/**
42
* @dev Returns the admin role that controls `role`. See {grantRole} and
43
* {revokeRole}.
44
*
45
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
46
*/
47
function getRoleAdmin(bytes32 role) external view returns (bytes32);
48
49
/**
50
* @dev Grants `role` to `account`.
51
*
52
* If `account` had not been already granted `role`, emits a {RoleGranted}
53
* event.
54
*
55
* Requirements:
56
*
57
* - the caller must have ``role``'s admin role.
58
*/
59
function grantRole(bytes32 role, address account) external;
60
61
/**
62
* @dev Revokes `role` from `account`.
63
*
64
* If `account` had been granted `role`, emits a {RoleRevoked} event.
65
*
66
* Requirements:
67
*
68
* - the caller must have ``role``'s admin role.
69
*/
70
function revokeRole(bytes32 role, address account) external;
71
72
/**
73
* @dev Revokes `role` from the calling account.
74
*
75
* Roles are often managed via {grantRole} and {revokeRole}: this function's
76
* purpose is to provide a mechanism for accounts to lose their privileges
77
* if they are compromised (such as when a trusted device is misplaced).
78
*
79
* If the calling account had been granted `role`, emits a {RoleRevoked}
80
* event.
81
*
82
* Requirements:
83
*
84
* - the caller must be `account`.
85
*/
86
function renounceRole(bytes32 role, address account) external;
87
}
88
89
/**
90
* @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
91
*/
92
interface IAccessControlEnumerable is IAccessControl {
93
/**
94
* @dev Returns one of the accounts that have `role`. `index` must be a
95
* value between 0 and {getRoleMemberCount}, non-inclusive.
96
*
97
* Role bearers are not sorted in any particular way, and their ordering may
98
* change at any point.
99
*
100
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
101
* you perform all queries on the same block. See the following
102
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
103
* for more information.
104
*/
105
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
106
107
/**
108
* @dev Returns the number of accounts that have `role`. Can be used
109
* together with {getRoleMember} to enumerate all bearers of a role.
110
*/
111
function getRoleMemberCount(bytes32 role) external view returns (uint256);
112
}
113
114
/**
115
* @dev Provides information about the current execution context, including the
116
* sender of the transaction and its data. While these are generally available
117
* via msg.sender and msg.data, they should not be accessed in such a direct
118
* manner, since when dealing with meta-transactions the account sending and
119
* paying for execution may not be the actual sender (as far as an application
120
* is concerned).
121
*
122
* This contract is only required for intermediate, library-like contracts.
123
*/
124
abstract contract Context {
125
function _msgSender() internal view virtual returns (address) {
126
return msg.sender;
127
}
128
129
function _msgData() internal view virtual returns (bytes calldata) {
130
return msg.data;
131
}
132
}
133
134
/**
135
* @dev String operations.
136
*/
137
library Strings {
138
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
139
140
/**
141
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
142
*/
143
function toString(uint256 value) internal pure returns (string memory) {
144
// Inspired by OraclizeAPI's implementation - MIT licence
145
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
146
147
if (value == 0) {
148
return "0";
149
}
150
uint256 temp = value;
151
uint256 digits;
152
while (temp != 0) {
153
digits++;
154
temp /= 10;
155
}
156
bytes memory buffer = new bytes(digits);
157
while (value != 0) {
158
digits -= 1;
159
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
160
value /= 10;
161
}
162
return string(buffer);
163
}
164
165
/**
166
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
167
*/
168
function toHexString(uint256 value) internal pure returns (string memory) {
169
if (value == 0) {
170
return "0x00";
171
}
172
uint256 temp = value;
173
uint256 length = 0;
174
while (temp != 0) {
175
length++;
176
temp >>= 8;
177
}
178
return toHexString(value, length);
179
}
180
181
/**
182
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
183
*/
184
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
185
bytes memory buffer = new bytes(2 * length + 2);
186
buffer[0] = "0";
187
buffer[1] = "x";
188
for (uint256 i = 2 * length + 1; i > 1; --i) {
189
buffer[i] = _HEX_SYMBOLS[value & 0xf];
190
value >>= 4;
191
}
192
require(value == 0, "Strings: hex length insufficient");
193
return string(buffer);
194
}
195
}
196
197
interface IERC165 {
198
/**
199
* @dev Returns true if this contract implements the interface defined by
200
* `interfaceId`. See the corresponding
201
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
202
* to learn more about how these ids are created.
203
*
204
* This function call must use less than 30 000 gas.
205
*/
206
function supportsInterface(bytes4 interfaceId) external view returns (bool);
207
}
208
209
/**
210
* @dev Implementation of the {IERC165} interface.
211
*
212
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
213
* for the additional interface id that will be supported. For example:
214
*
215
* ```solidity
216
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
217
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
218
* }
219
* ```
220
*
221
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
222
*/
223
abstract contract ERC165 is IERC165 {
224
/**
225
* @dev See {IERC165-supportsInterface}.
226
*/
227
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
228
return interfaceId == type(IERC165).interfaceId;
229
}
230
}
231
232
/**
233
* @dev Contract module that allows children to implement role-based access
234
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
235
* members except through off-chain means by accessing the contract event logs. Some
236
* applications may benefit from on-chain enumerability, for those cases see
237
* {AccessControlEnumerable}.
238
*
239
* Roles are referred to by their `bytes32` identifier. These should be exposed
240
* in the external API and be unique. The best way to achieve this is by
241
* using `public constant` hash digests:
242
*
243
* ```
244
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
245
* ```
246
*
247
* Roles can be used to represent a set of permissions. To restrict access to a
248
* function call, use {hasRole}:
249
*
250
* ```
251
* function foo() public {
252
* require(hasRole(MY_ROLE, msg.sender));
253
* ...
254
* }
255
* ```
256
*
257
* Roles can be granted and revoked dynamically via the {grantRole} and
258
* {revokeRole} functions. Each role has an associated admin role, and only
259
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
260
*
261
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
262
* that only accounts with this role will be able to grant or revoke other
263
* roles. More complex role relationships can be created by using
264
* {_setRoleAdmin}.
265
*
266
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
267
* grant and revoke this role. Extra precautions should be taken to secure
268
* accounts that have been granted it.
269
*/
270
abstract contract AccessControl is Context, IAccessControl, ERC165 {
271
struct RoleData {
272
mapping(address => bool) members;
273
bytes32 adminRole;
274
}
275
276
mapping(bytes32 => RoleData) private _roles;
277
278
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
279
280
/**
281
* @dev Modifier that checks that an account has a specific role. Reverts
282
* with a standardized message including the required role.
283
*
284
* The format of the revert reason is given by the following regular expression:
285
*
286
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
287
*
288
* _Available since v4.1._
289
*/
290
modifier onlyRole(bytes32 role) {
291
_checkRole(role, _msgSender());
292
_;
293
}
294
295
/**
296
* @dev See {IERC165-supportsInterface}.
297
*/
298
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
299
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
300
}
301
302
/**
303
* @dev Returns `true` if `account` has been granted `role`.
304
*/
305
function hasRole(bytes32 role, address account) public view override returns (bool) {
306
return _roles[role].members[account];
307
}
308
309
/**
310
* @dev Revert with a standard message if `account` is missing `role`.
311
*
312
* The format of the revert reason is given by the following regular expression:
313
*
314
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
315
*/
316
function _checkRole(bytes32 role, address account) internal view {
317
if (!hasRole(role, account)) {
318
revert(
319
string(
320
abi.encodePacked(
321
"AccessControl: account ",
322
Strings.toHexString(uint160(account), 20),
323
" is missing role ",
324
Strings.toHexString(uint256(role), 32)
325
)
326
)
327
);
328
}
329
}
330
331
/**
332
* @dev Returns the admin role that controls `role`. See {grantRole} and
333
* {revokeRole}.
334
*
335
* To change a role's admin, use {_setRoleAdmin}.
336
*/
337
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
338
return _roles[role].adminRole;
339
}
340
341
/**
342
* @dev Grants `role` to `account`.
343
*
344
* If `account` had not been already granted `role`, emits a {RoleGranted}
345
* event.
346
*
347
* Requirements:
348
*
349
* - the caller must have ``role``'s admin role.
350
*/
351
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
352
_grantRole(role, account);
353
}
354
355
/**
356
* @dev Revokes `role` from `account`.
357
*
358
* If `account` had been granted `role`, emits a {RoleRevoked} event.
359
*
360
* Requirements:
361
*
362
* - the caller must have ``role``'s admin role.
363
*/
364
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
365
_revokeRole(role, account);
366
}
367
368
/**
369
* @dev Revokes `role` from the calling account.
370
*
371
* Roles are often managed via {grantRole} and {revokeRole}: this function's
372
* purpose is to provide a mechanism for accounts to lose their privileges
373
* if they are compromised (such as when a trusted device is misplaced).
374
*
375
* If the calling account had been granted `role`, emits a {RoleRevoked}
376
* event.
377
*
378
* Requirements:
379
*
380
* - the caller must be `account`.
381
*/
382
function renounceRole(bytes32 role, address account) public virtual override {
383
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
384
385
_revokeRole(role, account);
386
}
387
388
/**
389
* @dev Grants `role` to `account`.
390
*
391
* If `account` had not been already granted `role`, emits a {RoleGranted}
392
* event. Note that unlike {grantRole}, this function doesn't perform any
393
* checks on the calling account.
394
*
395
* [WARNING]
396
* ====
397
* This function should only be called from the constructor when setting
398
* up the initial roles for the system.
399
*
400
* Using this function in any other way is effectively circumventing the admin
401
* system imposed by {AccessControl}.
402
* ====
403
*/
404
function _setupRole(bytes32 role, address account) internal virtual {
405
_grantRole(role, account);
406
}
407
408
/**
409
* @dev Sets `adminRole` as ``role``'s admin role.
410
*
411
* Emits a {RoleAdminChanged} event.
412
*/
413
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
414
bytes32 previousAdminRole = getRoleAdmin(role);
415
_roles[role].adminRole = adminRole;
416
emit RoleAdminChanged(role, previousAdminRole, adminRole);
417
}
418
419
function _grantRole(bytes32 role, address account) private {
420
if (!hasRole(role, account)) {
421
_roles[role].members[account] = true;
422
emit RoleGranted(role, account, _msgSender());
423
}
424
}
425
426
function _revokeRole(bytes32 role, address account) private {
427
if (hasRole(role, account)) {
428
_roles[role].members[account] = false;
429
emit RoleRevoked(role, account, _msgSender());
430
}
431
}
432
}
433
434
/**
435
* @dev Library for managing
436
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
437
* types.
438
*
439
* Sets have the following properties:
440
*
441
* - Elements are added, removed, and checked for existence in constant time
442
* (O(1)).
443
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
444
*
445
* ```
446
* contract Example {
447
* // Add the library methods
448
* using EnumerableSet for EnumerableSet.AddressSet;
449
*
450
* // Declare a set state variable
451
* EnumerableSet.AddressSet private mySet;
452
* }
453
* ```
454
*
455
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
456
* and `uint256` (`UintSet`) are supported.
457
*/
458
library EnumerableSet {
459
// To implement this library for multiple types with as little code
460
// repetition as possible, we write it in terms of a generic Set type with
461
// bytes32 values.
462
// The Set implementation uses private functions, and user-facing
463
// implementations (such as AddressSet) are just wrappers around the
464
// underlying Set.
465
// This means that we can only create new EnumerableSets for types that fit
466
// in bytes32.
467
468
struct Set {
469
// Storage of set values
470
bytes32[] _values;
471
// Position of the value in the `values` array, plus 1 because index 0
472
// means a value is not in the set.
473
mapping(bytes32 => uint256) _indexes;
474
}
475
476
/**
477
* @dev Add a value to a set. O(1).
478
*
479
* Returns true if the value was added to the set, that is if it was not
480
* already present.
481
*/
482
function _add(Set storage set, bytes32 value) private returns (bool) {
483
if (!_contains(set, value)) {
484
set._values.push(value);
485
// The value is stored at length-1, but we add 1 to all indexes
486
// and use 0 as a sentinel value
487
set._indexes[value] = set._values.length;
488
return true;
489
} else {
490
return false;
491
}
492
}
493
494
/**
495
* @dev Removes a value from a set. O(1).
496
*
497
* Returns true if the value was removed from the set, that is if it was
498
* present.
499
*/
500
function _remove(Set storage set, bytes32 value) private returns (bool) {
501
// We read and store the value's index to prevent multiple reads from the same storage slot
502
uint256 valueIndex = set._indexes[value];
503
504
if (valueIndex != 0) {
505
// Equivalent to contains(set, value)
506
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
507
// the array, and then remove the last element (sometimes called as 'swap and pop').
508
// This modifies the order of the array, as noted in {at}.
509
510
uint256 toDeleteIndex = valueIndex - 1;
511
uint256 lastIndex = set._values.length - 1;
512
513
if (lastIndex != toDeleteIndex) {
514
bytes32 lastvalue = set._values[lastIndex];
515
516
// Move the last value to the index where the value to delete is
517
set._values[toDeleteIndex] = lastvalue;
518
// Update the index for the moved value
519
set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
520
}
521
522
// Delete the slot where the moved value was stored
523
set._values.pop();
524
525
// Delete the index for the deleted slot
526
delete set._indexes[value];
527
528
return true;
529
} else {
530
return false;
531
}
532
}
533
534
/**
535
* @dev Returns true if the value is in the set. O(1).
536
*/
537
function _contains(Set storage set, bytes32 value) private view returns (bool) {
538
return set._indexes[value] != 0;
539
}
540
541
/**
542
* @dev Returns the number of values on the set. O(1).
543
*/
544
function _length(Set storage set) private view returns (uint256) {
545
return set._values.length;
546
}
547
548
/**
549
* @dev Returns the value stored at position `index` in the set. O(1).
550
*
551
* Note that there are no guarantees on the ordering of values inside the
552
* array, and it may change when more values are added or removed.
553
*
554
* Requirements:
555
*
556
* - `index` must be strictly less than {length}.
557
*/
558
function _at(Set storage set, uint256 index) private view returns (bytes32) {
559
return set._values[index];
560
}
561
562
/**
563
* @dev Return the entire set in an array
564
*
565
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
566
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
567
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
568
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
569
*/
570
function _values(Set storage set) private view returns (bytes32[] memory) {
571
return set._values;
572
}
573
574
// Bytes32Set
575
576
struct Bytes32Set {
577
Set _inner;
578
}
579
580
/**
581
* @dev Add a value to a set. O(1).
582
*
583
* Returns true if the value was added to the set, that is if it was not
584
* already present.
585
*/
586
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
587
return _add(set._inner, value);
588
}
589
590
/**
591
* @dev Removes a value from a set. O(1).
592
*
593
* Returns true if the value was removed from the set, that is if it was
594
* present.
595
*/
596
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
597
return _remove(set._inner, value);
598
}
599
600
/**
601
* @dev Returns true if the value is in the set. O(1).
602
*/
603
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
604
return _contains(set._inner, value);
605
}
606
607
/**
608
* @dev Returns the number of values in the set. O(1).
609
*/
610
function length(Bytes32Set storage set) internal view returns (uint256) {
611
return _length(set._inner);
612
}
613
614
/**
615
* @dev Returns the value stored at position `index` in the set. O(1).
616
*
617
* Note that there are no guarantees on the ordering of values inside the
618
* array, and it may change when more values are added or removed.
619
*
620
* Requirements:
621
*
622
* - `index` must be strictly less than {length}.
623
*/
624
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
625
return _at(set._inner, index);
626
}
627
628
/**
629
* @dev Return the entire set in an array
630
*
631
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
632
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
633
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
634
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
635
*/
636
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
637
return _values(set._inner);
638
}
639
640
// AddressSet
641
642
struct AddressSet {
643
Set _inner;
644
}
645
646
/**
647
* @dev Add a value to a set. O(1).
648
*
649
* Returns true if the value was added to the set, that is if it was not
650
* already present.
651
*/
652
function add(AddressSet storage set, address value) internal returns (bool) {
653
return _add(set._inner, bytes32(uint256(uint160(value))));
654
}
655
656
/**
657
* @dev Removes a value from a set. O(1).
658
*
659
* Returns true if the value was removed from the set, that is if it was
660
* present.
661
*/
662
function remove(AddressSet storage set, address value) internal returns (bool) {
663
return _remove(set._inner, bytes32(uint256(uint160(value))));
664
}
665
666
/**
667
* @dev Returns true if the value is in the set. O(1).
668
*/
669
function contains(AddressSet storage set, address value) internal view returns (bool) {
670
return _contains(set._inner, bytes32(uint256(uint160(value))));
671
}
672
673
/**
674
* @dev Returns the number of values in the set. O(1).
675
*/
676
function length(AddressSet storage set) internal view returns (uint256) {
677
return _length(set._inner);
678
}
679
680
/**
681
* @dev Returns the value stored at position `index` in the set. O(1).
682
*
683
* Note that there are no guarantees on the ordering of values inside the
684
* array, and it may change when more values are added or removed.
685
*
686
* Requirements:
687
*
688
* - `index` must be strictly less than {length}.
689
*/
690
function at(AddressSet storage set, uint256 index) internal view returns (address) {
691
return address(uint160(uint256(_at(set._inner, index))));
692
}
693
694
/**
695
* @dev Return the entire set in an array
696
*
697
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
698
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
699
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
700
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
701
*/
702
function values(AddressSet storage set) internal view returns (address[] memory) {
703
bytes32[] memory store = _values(set._inner);
704
address[] memory result;
705
706
assembly {
707
result := store
708
}
709
710
return result;
711
}
712
713
// UintSet
714
715
struct UintSet {
716
Set _inner;
717
}
718
719
/**
720
* @dev Add a value to a set. O(1).
721
*
722
* Returns true if the value was added to the set, that is if it was not
723
* already present.
724
*/
725
function add(UintSet storage set, uint256 value) internal returns (bool) {
726
return _add(set._inner, bytes32(value));
727
}
728
729
/**
730
* @dev Removes a value from a set. O(1).
731
*
732
* Returns true if the value was removed from the set, that is if it was
733
* present.
734
*/
735
function remove(UintSet storage set, uint256 value) internal returns (bool) {
736
return _remove(set._inner, bytes32(value));
737
}
738
739
/**
740
* @dev Returns true if the value is in the set. O(1).
741
*/
742
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
743
return _contains(set._inner, bytes32(value));
744
}
745
746
/**
747
* @dev Returns the number of values on the set. O(1).
748
*/
749
function length(UintSet storage set) internal view returns (uint256) {
750
return _length(set._inner);
751
}
752
753
/**
754
* @dev Returns the value stored at position `index` in the set. O(1).
755
*
756
* Note that there are no guarantees on the ordering of values inside the
757
* array, and it may change when more values are added or removed.
758
*
759
* Requirements:
760
*
761
* - `index` must be strictly less than {length}.
762
*/
763
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
764
return uint256(_at(set._inner, index));
765
}
766
767
/**
768
* @dev Return the entire set in an array
769
*
770
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
771
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
772
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
773
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
774
*/
775
function values(UintSet storage set) internal view returns (uint256[] memory) {
776
bytes32[] memory store = _values(set._inner);
777
uint256[] memory result;
778
779
assembly {
780
result := store
781
}
782
783
return result;
784
}
785
}
786
787
/**
788
* @dev Extension of {AccessControl} that allows enumerating the members of each role.
789
*/
790
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
791
using EnumerableSet for EnumerableSet.AddressSet;
792
793
mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;
794
795
/**
796
* @dev See {IERC165-supportsInterface}.
797
*/
798
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
799
return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
800
}
801
802
/**
803
* @dev Returns one of the accounts that have `role`. `index` must be a
804
* value between 0 and {getRoleMemberCount}, non-inclusive.
805
*
806
* Role bearers are not sorted in any particular way, and their ordering may
807
* change at any point.
808
*
809
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
810
* you perform all queries on the same block. See the following
811
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
812
* for more information.
813
*/
814
function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
815
return _roleMembers[role].at(index);
816
}
817
818
/**
819
* @dev Returns the number of accounts that have `role`. Can be used
820
* together with {getRoleMember} to enumerate all bearers of a role.
821
*/
822
function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
823
return _roleMembers[role].length();
824
}
825
826
/**
827
* @dev Overload {grantRole} to track enumerable memberships
828
*/
829
function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
830
super.grantRole(role, account);
831
_roleMembers[role].add(account);
832
}
833
834
/**
835
* @dev Overload {revokeRole} to track enumerable memberships
836
*/
837
function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
838
super.revokeRole(role, account);
839
_roleMembers[role].remove(account);
840
}
841
842
/**
843
* @dev Overload {renounceRole} to track enumerable memberships
844
*/
845
function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
846
super.renounceRole(role, account);
847
_roleMembers[role].remove(account);
848
}
849
850
/**
851
* @dev Overload {_setupRole} to track enumerable memberships
852
*/
853
function _setupRole(bytes32 role, address account) internal virtual override {
854
super._setupRole(role, account);
855
_roleMembers[role].add(account);
856
}
857
}
858
859
contract KYCContract is AccessControlEnumerable {
860
861
// Simple mapping, 0 means the user has not passed anything.
862
mapping(address => uint) public level;
863
864
// Prices for every KYC-Tier.
865
mapping(uint => uint) public levelPrices;
866
867
// KYC centre which is allowed to change users' kyc levels.
868
bytes32 public constant KYCCentre = keccak256("KYCCentre");
869
870
event KYCLevelChanged(address indexed _address, uint indexed level);
871
event RequestCreated(uint indexed index);
872
event RequestApproved(uint indexed index);
873
event RequestDeclined(uint indexed index);
874
event RequestWithdrawn(uint indexed index);
875
event SetLevelPrice(uint indexed level, uint indexed price);
876
877
878
// So centre can view requests assigned to him.
879
mapping(address => uint[]) public kycCentreRequests;
880
881
// so user can view his own requests.
882
mapping(address => uint[]) public userKYCRequests;
883
884
enum Status {
885
Pending,
886
Declined,
887
Approved,
888
Withdrawn
889
}
890
891
// Request from user to KYC centre.
892
struct KYCRequest {
893
address user;
894
bytes32 data;
895
uint level;
896
Status status;
897
address centre;
898
uint deposit;
899
}
900
901
// All requests from users to KYC centres.
902
KYCRequest[] public kycRequests;
903
904
/**
905
* Checks if the user has enough deposit and returns the change.
906
*/
907
modifier costs(uint _amount) {
908
require(msg.value >= _amount, "G001");
909
_;
910
if (msg.value > _amount)
911
payable(msg.sender).transfer(msg.value - _amount);
912
}
913
914
/**
915
* Setter of the KYC-Tier prices.
916
*/
917
function setLevelPrice(uint _level, uint price) external {
918
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "G053");
919
levelPrices[_level] = price;
920
emit SetLevelPrice(_level, price);
921
}
922
923
/**
924
* Creates user request and sends it to the random chosen KYC centre.
925
*/
926
function createKYCRequest(uint _level, bytes32 _data) external payable costs(levelPrices[_level]) {
927
require(level[msg.sender] < _level, "G002");
928
929
uint length = userKYCRequests[msg.sender].length;
930
if (length > 0) {
931
uint requestIndex = userKYCRequests[msg.sender][length-1];
932
require(kycRequests[requestIndex].status != Status.Pending, "G120");
933
}
934
935
uint count = getRoleMemberCount(KYCCentre);
936
require(count > 0, "G111");
937
938
uint index = uint(blockhash(block.number-1)) % count;
939
address chosenKYCCentre = getRoleMember(KYCCentre, index);
940
941
KYCRequest memory request = KYCRequest({
942
user: msg.sender,
943
data: _data,
944
level: _level,
945
status: Status.Pending,
946
centre: chosenKYCCentre,
947
deposit: levelPrices[_level]
948
});
949
950
kycRequests.push(request);
951
952
uint indexInAll = kycRequests.length-1;
953
954
kycCentreRequests[chosenKYCCentre].push(indexInAll);
955
956
// Store the index in the all list.
957
userKYCRequests[msg.sender].push(indexInAll);
958
emit RequestCreated(kycRequests.length-1);
959
}
960
961
/**
962
* KYC centre function.
963
* Approve users request by a global index.
964
*/
965
function approveKYCRequest(uint _index) external {
966
require(hasRole(KYCCentre, msg.sender), "G052");
967
KYCRequest storage request = kycRequests[_index];
968
969
require(msg.sender == request.centre, "G114");
970
require(request.status == Status.Pending, "G121");
971
request.status = Status.Approved;
972
level[request.user] = request.level;
973
974
// We pay half of the deposit back to user if KYC centre approved request
975
uint halvedDeposit = request.deposit / 2;
976
payable(request.user).transfer(halvedDeposit);
977
payable(msg.sender).transfer(request.deposit - halvedDeposit);
978
979
emit KYCLevelChanged(request.user, request.level);
980
emit RequestApproved(_index);
981
}
982
983
/**
984
* KYC centre function.
985
* Decline users request.
986
*/
987
function declineKYCRequest(uint _index) external {
988
require(hasRole(KYCCentre, msg.sender), "G050");
989
KYCRequest storage request = kycRequests[_index];
990
991
require(msg.sender == request.centre, "G114");
992
require(request.status == Status.Pending, "G121");
993
request.status = Status.Declined;
994
995
payable(msg.sender).transfer(request.deposit);
996
emit RequestDeclined(_index);
997
}
998
999
/**
1000
* KYC centre function.
1001
* Decrease users KYC level.
1002
*/
1003
function decreaseKYCLevel(address user, uint _level) external {
1004
require(hasRole(KYCCentre, msg.sender), "G051");
1005
1006
uint length = userKYCRequests[user].length;
1007
uint requestIndex = userKYCRequests[user][length-1];
1008
require(msg.sender == kycRequests[requestIndex].centre, "G114");
1009
1010
require(_level < level[user], "G112");
1011
level[user] = _level;
1012
1013
emit KYCLevelChanged(user, _level);
1014
}
1015
1016
/**
1017
* Users function.
1018
* In case the KYCCentre has been renounced user may withdraw his request.
1019
*/
1020
function repairLostRequest() external {
1021
uint length = userKYCRequests[msg.sender].length;
1022
uint requestIndex = userKYCRequests[msg.sender][length-1];
1023
1024
KYCRequest storage request = kycRequests[requestIndex];
1025
require(msg.sender == request.user, "G053");
1026
require(!hasRole(KYCCentre, request.centre), "G110");
1027
require(request.status == Status.Pending, "G122");
1028
1029
request.status = Status.Withdrawn;
1030
1031
payable(request.user).transfer(request.deposit);
1032
emit RequestWithdrawn(requestIndex);
1033
}
1034
1035
/**
1036
* Users function.
1037
* User may cancel its KYC request.
1038
*/
1039
function cancelUsersRequest() external {
1040
uint length = userKYCRequests[msg.sender].length;
1041
uint requestIndex = userKYCRequests[msg.sender][length-1];
1042
1043
KYCRequest storage request = kycRequests[requestIndex];
1044
require(msg.sender == request.user, "G053");
1045
require(hasRole(KYCCentre, request.centre), "G113");
1046
require(request.status == Status.Pending, "G123");
1047
1048
request.status = Status.Withdrawn;
1049
1050
payable(request.centre).transfer(request.deposit);
1051
emit RequestWithdrawn(requestIndex);
1052
}
1053
1054
/**
1055
* Getter of the user requests and their statuses.
1056
*/
1057
function viewMyRequest(uint userIndex) external view returns(KYCRequest memory) {
1058
uint indexInAll = userKYCRequests[msg.sender][userIndex];
1059
return kycRequests[indexInAll];
1060
}
1061
1062
/**
1063
* Getter of the user requests assigned to KYC centre.
1064
*/
1065
function viewRequestAssignedToCentre(address _centre, uint _localIndex) external view returns (KYCRequest memory, uint) {
1066
uint globalIndex = kycCentreRequests[_centre][_localIndex];
1067
KYCRequest memory request = kycRequests[globalIndex];
1068
return (request, globalIndex);
1069
}
1070
1071
/**
1072
* Getter of the last user request.
1073
*/
1074
function viewMyLastRequest() external view returns(KYCRequest memory) {
1075
uint len = userKYCRequests[msg.sender].length;
1076
uint indexInAll = userKYCRequests[msg.sender][len-1];
1077
return kycRequests[indexInAll];
1078
}
1079
1080
/**
1081
* Getter of the global index of a users last KYC-request.
1082
*/
1083
function getLastGlobalRequestIndexOfAddress(address _address) external view returns(uint){
1084
uint len = userKYCRequests[_address].length;
1085
uint index = userKYCRequests[_address][len-1];
1086
return index;
1087
}
1088
}