// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)pragmasolidity ^0.8.0;/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
* ====
*/libraryEnumerableSet{
// To implement this library for multiple types with as little code// repetition as possible, we write it in terms of a generic Set type with// bytes32 values.// The Set implementation uses private functions, and user-facing// implementations (such as AddressSet) are just wrappers around the// underlying Set.// This means that we can only create new EnumerableSets for types that fit// in bytes32.structSet {
// Storage of set valuesbytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0// means a value is not in the set.mapping(bytes32=>uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/function_add(Set storage set, bytes32 value) privatereturns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
returntrue;
} else {
returnfalse;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/function_remove(Set storage set, bytes32 value) privatereturns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slotuint256 valueIndex = set._indexes[value];
if (valueIndex !=0) {
// Equivalent to contains(set, value)// To delete an element from the _values array in O(1), we swap the element to delete with the last one in// the array, and then remove the last element (sometimes called as 'swap and pop').// This modifies the order of the array, as noted in {at}.uint256 toDeleteIndex = valueIndex -1;
uint256 lastIndex = set._values.length-1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slotdelete set._indexes[value];
returntrue;
} else {
returnfalse;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/function_contains(Set storage set, bytes32 value) privateviewreturns (bool) {
return set._indexes[value] !=0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/function_length(Set storage set) privateviewreturns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/function_at(Set storage set, uint256 index) privateviewreturns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/function_values(Set storage set) privateviewreturns (bytes32[] memory) {
return set._values;
}
// Bytes32SetstructBytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/functionadd(Bytes32Set storage set, bytes32 value) internalreturns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/functionremove(Bytes32Set storage set, bytes32 value) internalreturns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/functioncontains(Bytes32Set storage set, bytes32 value) internalviewreturns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/functionlength(Bytes32Set storage set) internalviewreturns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/functionat(Bytes32Set storage set, uint256 index) internalviewreturns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/functionvalues(Bytes32Set storage set) internalviewreturns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSetstructAddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/functionadd(AddressSet storage set, address value) internalreturns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/functionremove(AddressSet storage set, address value) internalreturns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/functioncontains(AddressSet storage set, address value) internalviewreturns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/functionlength(AddressSet storage set) internalviewreturns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/functionat(AddressSet storage set, uint256 index) internalviewreturns (address) {
returnaddress(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/functionvalues(AddressSet storage set) internalviewreturns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assemblyassembly {
result := store
}
return result;
}
// UintSetstructUintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/functionadd(UintSet storage set, uint256 value) internalreturns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/functionremove(UintSet storage set, uint256 value) internalreturns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/functioncontains(UintSet storage set, uint256 value) internalviewreturns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/functionlength(UintSet storage set) internalviewreturns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/functionat(UintSet storage set, uint256 index) internalviewreturns (uint256) {
returnuint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/functionvalues(UintSet storage set) internalviewreturns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assemblyassembly {
result := store
}
return result;
}
}
Contract Source Code
File 2 of 8: EnumerableValues.sol
// SPDX-License-Identifier: BUSL-1.1pragmasolidity ^0.8.0;import"@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* @title EnumerableValues
* @dev Library to extend the EnumerableSet library with functions to get
* valuesAt for a range
*/libraryEnumerableValues{
usingEnumerableSetforEnumerableSet.Bytes32Set;
usingEnumerableSetforEnumerableSet.AddressSet;
usingEnumerableSetforEnumerableSet.UintSet;
/**
* Returns an array of bytes32 values from the given set, starting at the given
* start index and ending before the given end index.
*
* @param set The set to get the values from.
* @param start The starting index.
* @param end The ending index.
* @return An array of bytes32 values.
*/functionvaluesAt(EnumerableSet.Bytes32Set storage set, uint256 start, uint256 end) internalviewreturns (bytes32[] memory) {
uint256 max = set.length();
if (end > max) { end = max; }
bytes32[] memory items =newbytes32[](end - start);
for (uint256 i = start; i < end; i++) {
items[i - start] = set.at(i);
}
return items;
}
/**
* Returns an array of address values from the given set, starting at the given
* start index and ending before the given end index.
*
* @param set The set to get the values from.
* @param start The starting index.
* @param end The ending index.
* @return An array of address values.
*/functionvaluesAt(EnumerableSet.AddressSet storage set, uint256 start, uint256 end) internalviewreturns (address[] memory) {
uint256 max = set.length();
if (end > max) { end = max; }
address[] memory items =newaddress[](end - start);
for (uint256 i = start; i < end; i++) {
items[i - start] = set.at(i);
}
return items;
}
/**
* Returns an array of uint256 values from the given set, starting at the given
* start index and ending before the given end index, the item at the end index will not be returned.
*
* @param set The set to get the values from.
* @param start The starting index (inclusive, item at the start index will be returned).
* @param end The ending index (exclusive, item at the end index will not be returned).
* @return An array of uint256 values.
*/functionvaluesAt(EnumerableSet.UintSet storage set, uint256 start, uint256 end) internalviewreturns (uint256[] memory) {
if (start >= set.length()) {
returnnewuint256[](0);
}
uint256 max = set.length();
if (end > max) { end = max; }
uint256[] memory items =newuint256[](end - start);
for (uint256 i = start; i < end; i++) {
items[i - start] = set.at(i);
}
return items;
}
}
// SPDX-License-Identifier: BUSL-1.1pragmasolidity ^0.8.0;/**
* @title Role
* @dev Library for role keys
*/libraryRole{
/**
* @dev The ROLE_ADMIN role.
*/bytes32publicconstant ROLE_ADMIN =keccak256(abi.encode("ROLE_ADMIN"));
/**
* @dev The TIMELOCK_ADMIN role.
*/bytes32publicconstant TIMELOCK_ADMIN =keccak256(abi.encode("TIMELOCK_ADMIN"));
/**
* @dev The TIMELOCK_MULTISIG role.
*/bytes32publicconstant TIMELOCK_MULTISIG =keccak256(abi.encode("TIMELOCK_MULTISIG"));
/**
* @dev The CONFIG_KEEPER role.
*/bytes32publicconstant CONFIG_KEEPER =keccak256(abi.encode("CONFIG_KEEPER"));
/**
* @dev The CONTROLLER role.
*/bytes32publicconstant CONTROLLER =keccak256(abi.encode("CONTROLLER"));
/**
* @dev The ROUTER_PLUGIN role.
*/bytes32publicconstant ROUTER_PLUGIN =keccak256(abi.encode("ROUTER_PLUGIN"));
/**
* @dev The MARKET_KEEPER role.
*/bytes32publicconstant MARKET_KEEPER =keccak256(abi.encode("MARKET_KEEPER"));
/**
* @dev The FEE_KEEPER role.
*/bytes32publicconstant FEE_KEEPER =keccak256(abi.encode("FEE_KEEPER"));
/**
* @dev The ORDER_KEEPER role.
*/bytes32publicconstant ORDER_KEEPER =keccak256(abi.encode("ORDER_KEEPER"));
/**
* @dev The FROZEN_ORDER_KEEPER role.
*/bytes32publicconstant FROZEN_ORDER_KEEPER =keccak256(abi.encode("FROZEN_ORDER_KEEPER"));
/**
* @dev The PRICING_KEEPER role.
*/bytes32publicconstant PRICING_KEEPER =keccak256(abi.encode("PRICING_KEEPER"));
/**
* @dev The LIQUIDATION_KEEPER role.
*/bytes32publicconstant LIQUIDATION_KEEPER =keccak256(abi.encode("LIQUIDATION_KEEPER"));
/**
* @dev The ADL_KEEPER role.
*/bytes32publicconstant ADL_KEEPER =keccak256(abi.encode("ADL_KEEPER"));
}
Contract Source Code
File 7 of 8: RoleModule.sol
// SPDX-License-Identifier: BUSL-1.1pragmasolidity ^0.8.0;import"./RoleStore.sol";
/**
* @title RoleModule
* @dev Contract for role validation functions
*/contractRoleModule{
RoleStore publicimmutable roleStore;
/**
* @dev Constructor that initializes the role store for this contract.
*
* @param _roleStore The contract instance to use as the role store.
*/constructor(RoleStore _roleStore) {
roleStore = _roleStore;
}
/**
* @dev Only allows the contract's own address to call the function.
*/modifieronlySelf() {
if (msg.sender!=address(this)) {
revert Errors.Unauthorized(msg.sender, "SELF");
}
_;
}
/**
* @dev Only allows addresses with the TIMELOCK_MULTISIG role to call the function.
*/modifieronlyTimelockMultisig() {
_validateRole(Role.TIMELOCK_MULTISIG, "TIMELOCK_MULTISIG");
_;
}
/**
* @dev Only allows addresses with the TIMELOCK_ADMIN role to call the function.
*/modifieronlyTimelockAdmin() {
_validateRole(Role.TIMELOCK_ADMIN, "TIMELOCK_ADMIN");
_;
}
/**
* @dev Only allows addresses with the CONFIG_KEEPER role to call the function.
*/modifieronlyConfigKeeper() {
_validateRole(Role.CONFIG_KEEPER, "CONFIG_KEEPER");
_;
}
/**
* @dev Only allows addresses with the CONTROLLER role to call the function.
*/modifieronlyController() {
_validateRole(Role.CONTROLLER, "CONTROLLER");
_;
}
/**
* @dev Only allows addresses with the ROUTER_PLUGIN role to call the function.
*/modifieronlyRouterPlugin() {
_validateRole(Role.ROUTER_PLUGIN, "ROUTER_PLUGIN");
_;
}
/**
* @dev Only allows addresses with the MARKET_KEEPER role to call the function.
*/modifieronlyMarketKeeper() {
_validateRole(Role.MARKET_KEEPER, "MARKET_KEEPER");
_;
}
/**
* @dev Only allows addresses with the FEE_KEEPER role to call the function.
*/modifieronlyFeeKeeper() {
_validateRole(Role.FEE_KEEPER, "FEE_KEEPER");
_;
}
/**
* @dev Only allows addresses with the ORDER_KEEPER role to call the function.
*/modifieronlyOrderKeeper() {
_validateRole(Role.ORDER_KEEPER, "ORDER_KEEPER");
_;
}
/**
* @dev Only allows addresses with the PRICING_KEEPER role to call the function.
*/modifieronlyPricingKeeper() {
_validateRole(Role.PRICING_KEEPER, "PRICING_KEEPER");
_;
}
/**
* @dev Only allows addresses with the LIQUIDATION_KEEPER role to call the function.
*/modifieronlyLiquidationKeeper() {
_validateRole(Role.LIQUIDATION_KEEPER, "LIQUIDATION_KEEPER");
_;
}
/**
* @dev Only allows addresses with the ADL_KEEPER role to call the function.
*/modifieronlyAdlKeeper() {
_validateRole(Role.ADL_KEEPER, "ADL_KEEPER");
_;
}
/**
* @dev Validates that the caller has the specified role.
*
* If the caller does not have the specified role, the transaction is reverted.
*
* @param role The key of the role to validate.
* @param roleName The name of the role to validate.
*/function_validateRole(bytes32 role, stringmemory roleName) internalview{
if (!roleStore.hasRole(msg.sender, role)) {
revert Errors.Unauthorized(msg.sender, roleName);
}
}
}
Contract Source Code
File 8 of 8: RoleStore.sol
// SPDX-License-Identifier: BUSL-1.1pragmasolidity ^0.8.0;import"@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import"../utils/EnumerableValues.sol";
import"./Role.sol";
import"../error/Errors.sol";
/**
* @title RoleStore
* @dev Stores roles and their members.
*/contractRoleStore{
usingEnumerableSetforEnumerableSet.AddressSet;
usingEnumerableSetforEnumerableSet.Bytes32Set;
usingEnumerableValuesforEnumerableSet.AddressSet;
usingEnumerableValuesforEnumerableSet.Bytes32Set;
EnumerableSet.Bytes32Set internal roles;
mapping(bytes32=> EnumerableSet.AddressSet) internal roleMembers;
// checking if an account has a role is a frequently used function// roleCache helps to save gas by offering a more efficient lookup// vs calling roleMembers[key].contains(account)mapping(address=>mapping (bytes32=>bool)) roleCache;
modifieronlyRoleAdmin() {
if (!hasRole(msg.sender, Role.ROLE_ADMIN)) {
revert Errors.Unauthorized(msg.sender, "ROLE_ADMIN");
}
_;
}
constructor() {
_grantRole(msg.sender, Role.ROLE_ADMIN);
}
/**
* @dev Grants the specified role to the given account.
*
* @param account The address of the account.
* @param roleKey The key of the role to grant.
*/functiongrantRole(address account, bytes32 roleKey) externalonlyRoleAdmin{
_grantRole(account, roleKey);
}
/**
* @dev Revokes the specified role from the given account.
*
* @param account The address of the account.
* @param roleKey The key of the role to revoke.
*/functionrevokeRole(address account, bytes32 roleKey) externalonlyRoleAdmin{
_revokeRole(account, roleKey);
}
/**
* @dev Returns true if the given account has the specified role.
*
* @param account The address of the account.
* @param roleKey The key of the role.
* @return True if the account has the role, false otherwise.
*/functionhasRole(address account, bytes32 roleKey) publicviewreturns (bool) {
return roleCache[account][roleKey];
}
/**
* @dev Returns the number of roles stored in the contract.
*
* @return The number of roles.
*/functiongetRoleCount() externalviewreturns (uint256) {
return roles.length();
}
/**
* @dev Returns the keys of the roles stored in the contract.
*
* @param start The starting index of the range of roles to return.
* @param end The ending index of the range of roles to return.
* @return The keys of the roles.
*/functiongetRoles(uint256 start, uint256 end) externalviewreturns (bytes32[] memory) {
return roles.valuesAt(start, end);
}
/**
* @dev Returns the number of members of the specified role.
*
* @param roleKey The key of the role.
* @return The number of members of the role.
*/functiongetRoleMemberCount(bytes32 roleKey) externalviewreturns (uint256) {
return roleMembers[roleKey].length();
}
/**
* @dev Returns the members of the specified role.
*
* @param roleKey The key of the role.
* @param start the start index, the value for this index will be included.
* @param end the end index, the value for this index will not be included.
* @return The members of the role.
*/functiongetRoleMembers(bytes32 roleKey, uint256 start, uint256 end) externalviewreturns (address[] memory) {
return roleMembers[roleKey].valuesAt(start, end);
}
function_grantRole(address account, bytes32 roleKey) internal{
roles.add(roleKey);
roleMembers[roleKey].add(account);
roleCache[account][roleKey] =true;
}
function_revokeRole(address account, bytes32 roleKey) internal{
roleMembers[roleKey].remove(account);
roleCache[account][roleKey] =false;
if (roleMembers[roleKey].length() ==0) {
if (roleKey == Role.ROLE_ADMIN) {
revert Errors.ThereMustBeAtLeastOneRoleAdmin();
}
if (roleKey == Role.TIMELOCK_MULTISIG) {
revert Errors.ThereMustBeAtLeastOneTimelockMultiSig();
}
}
}
}