feature: rename all instances of RoyaltyAllowlist to OperatorAllowlist (#73)

* feature: rename all instances of RoyaltyAllowlist to OperatorAllowlist

Author: Hayden

.prettierrc

@@ -1 +1,3 @@
-{}
+{
+  "printWidth": 120
+}

README.md

@@ -37,7 +37,7 @@ contract MyERC721 is ImmutableERC721PermissionedMintable {
         string memory symbol,
         string memory baseURI,
         string memory contractURI,
-        address royaltyAllowlist,
+        address operatorAllowlist,
         address receiver,
         uint96 feeNumerator
     ) ImmutableERC721PermissionedMintable(
@@ -46,7 +46,7 @@ contract MyERC721 is ImmutableERC721PermissionedMintable {
       symbol, 
       baseURI, 
       contractURI,
-      royaltyAllowlist,
+      operatorAllowlist,
       receiver, 
       feeNumerator
     ) 

contracts/access/IERC173.sol

@@ -5,10 +5,7 @@ import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
 
 interface IERC173 is IERC165 {
     /// @dev This emits when ownership of a contract changes.
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 
     /// @notice Get the address of the owner
     /// @return The address of the owner.

contracts/royalty-enforcement/IRoyaltyAllowlist.sol renamed to contracts/allowlist/IOperatorAllowlist.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 /**
- * @dev Required interface of an RoyaltyAllowlist compliant contract
+ * @dev Required interface of an OperatorAllowlist compliant contract
  */
-interface IRoyaltyAllowlist {
+interface IOperatorAllowlist {
     /// @dev Returns true if an address is Allowlisted false otherwise
     function isAllowlisted(address target) external view returns (bool);
 }

contracts/royalty-enforcement/RoyaltyAllowlist.sol renamed to contracts/allowlist/OperatorAllowlist.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 // Access Control
-import "@openzeppelin/contracts/access/AccessControl.sol";
+import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 
 // Introspection
-import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
 
 // Interfaces
-import "./IRoyaltyAllowlist.sol";
+import {IOperatorAllowlist} from "./IOperatorAllowlist.sol";
 
 // Interface to retrieve the implemention stored inside the Proxy contract
 interface IProxy {
@@ -17,23 +17,19 @@ interface IProxy {
 }
 
 /*
-    RoyaltyAllowlist is an implementation of a Allowlist registry, storing addresses and bytecode
+    OperatorAllowlist is an implementation of a Allowlist registry, storing addresses and bytecode
     which are allowed to be approved operators and execute transfers of interfacing token contracts (e.g. ERC721/ERC1155). The registry
     will be a deployed contract that tokens may interface with and point to.
 */
 
-contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
+contract OperatorAllowlist is ERC165, AccessControl, IOperatorAllowlist {
     ///     =====       Events       =====
 
     /// @dev Emitted when a target address is added or removed from the Allowlist
     event AddressAllowlistChanged(address indexed target, bool added);
 
     /// @dev Emitted when a target smart contract wallet is added or removed from the Allowlist
-    event WalletAllowlistChanged(
-        bytes32 indexed targetBytes,
-        address indexed targetAddress,
-        bool added
-    );
+    event WalletAllowlistChanged(bytes32 indexed targetBytes, address indexed targetAddress, bool added);
 
     ///     =====   State Variables  =====
 
@@ -61,18 +57,12 @@ contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
     ///     =====   View functions  =====
 
     /// @dev ERC-165 interface support
-    function supportsInterface(
-        bytes4 interfaceId
-    ) public view virtual override(ERC165, AccessControl) returns (bool) {
-        return
-            interfaceId == type(IRoyaltyAllowlist).interfaceId ||
-            super.supportsInterface(interfaceId);
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, AccessControl) returns (bool) {
+        return interfaceId == type(IOperatorAllowlist).interfaceId || super.supportsInterface(interfaceId);
     }
 
     /// @dev Returns true if an address is Allowlisted, false otherwise
-    function isAllowlisted(
-        address target
-    ) external view override returns (bool) {
+    function isAllowlisted(address target) external view override returns (bool) {
         if (addressAllowlist[target]) {
             return true;
         }
@@ -95,19 +85,15 @@ contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
     ///     =====  External functions  =====
 
     /// @dev Add a target address to Allowlist
-    function addAddressToAllowlist(
-        address[] calldata addressTargets
-    ) external onlyRole(REGISTRAR_ROLE) {
+    function addAddressToAllowlist(address[] calldata addressTargets) external onlyRole(REGISTRAR_ROLE) {
         for (uint256 i; i < addressTargets.length; i++) {
             addressAllowlist[addressTargets[i]] = true;
             emit AddressAllowlistChanged(addressTargets[i], true);
         }
     }
 
     /// @dev Remove a target address from Allowlist
-    function removeAddressFromAllowlist(
-        address[] calldata addressTargets
-    ) external onlyRole(REGISTRAR_ROLE) {
+    function removeAddressFromAllowlist(address[] calldata addressTargets) external onlyRole(REGISTRAR_ROLE) {
         for (uint256 i; i < addressTargets.length; i++) {
             delete addressAllowlist[addressTargets[i]];
             emit AddressAllowlistChanged(addressTargets[i], false);
@@ -119,9 +105,7 @@ contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
     // First, the bytecode of the proxy is added to the bytecode allowlist.
     // Second, the implementation address stored in the proxy is stored in the
     // implementation address allowlist.
-    function addWalletToAllowlist(
-        address walletAddr
-    ) external onlyRole(REGISTRAR_ROLE) {
+    function addWalletToAllowlist(address walletAddr) external onlyRole(REGISTRAR_ROLE) {
         // get bytecode of wallet
         bytes32 codeHash;
         assembly {
@@ -137,9 +121,7 @@ contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
 
     /// @dev Remove  a smart contract wallet from the Allowlist
     // This will remove the proxy bytecode hash and implementation contract address pair from the allowlist
-    function removeWalletFromAllowlist(
-        address walletAddr
-    ) external onlyRole(REGISTRAR_ROLE) {
+    function removeWalletFromAllowlist(address walletAddr) external onlyRole(REGISTRAR_ROLE) {
         // get bytecode of wallet
         bytes32 codeHash;
         assembly {
@@ -154,16 +136,12 @@ contract RoyaltyAllowlist is ERC165, AccessControl, IRoyaltyAllowlist {
     }
 
     /// @dev Allows admin to grant `user` `REGISTRAR_ROLE` role
-    function grantRegistrarRole(
-        address user
-    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
+    function grantRegistrarRole(address user) external onlyRole(DEFAULT_ADMIN_ROLE) {
         grantRole(REGISTRAR_ROLE, user);
     }
 
     /// @dev Allows admin to revoke `REGISTRAR_ROLE` role from `user`
-    function revokeRegistrarRole(
-        address user
-    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
+    function revokeRegistrarRole(address user) external onlyRole(DEFAULT_ADMIN_ROLE) {
         revokeRole(REGISTRAR_ROLE, user);
     }
 }

contracts/royalty-enforcement/RoyaltyEnforced.sol renamed to contracts/allowlist/OperatorAllowlistEnforced.sol

@@ -2,80 +2,57 @@
 pragma solidity ^0.8.0;
 
 // Allowlist Registry
-import "./IRoyaltyAllowlist.sol";
+import {IOperatorAllowlist} from "./IOperatorAllowlist.sol";
 
 // Access Control
-import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
+import {AccessControlEnumerable, IERC165} from "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
 
 // Errors
-import {RoyaltyEnforcementErrors} from "../errors/Errors.sol";
+import {OperatorAllowlistEnforcementErrors} from "../errors/Errors.sol";
 
-abstract contract RoyaltyEnforced is
-    AccessControlEnumerable,
-    RoyaltyEnforcementErrors
-{
+abstract contract OperatorAllowlistEnforced is AccessControlEnumerable, OperatorAllowlistEnforcementErrors {
     ///     =====     Events         =====
 
     /// @dev Emitted whenever the transfer Allowlist registry is updated
-    event RoyaltyAllowlistRegistryUpdated(
-        address oldRegistry,
-        address newRegistry
-    );
+    event OperatorAllowlistRegistryUpdated(address oldRegistry, address newRegistry);
 
     ///     =====   State Variables  =====
 
-    /// @dev Interface that implements the `IRoyaltyAllowlist` interface
-    IRoyaltyAllowlist public royaltyAllowlist;
+    /// @dev Interface that implements the `IOperatorAllowlist` interface
+    IOperatorAllowlist public operatorAllowlist;
 
     ///     =====  External functions  =====
 
     /// @dev Returns the supported interfaces
-    function supportsInterface(
-        bytes4 interfaceId
-    ) public view virtual override returns (bool) {
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
         return super.supportsInterface(interfaceId);
     }
 
-    function setRoyaltyAllowlistRegistry(
-        address _royaltyAllowlist
-    ) public onlyRole(DEFAULT_ADMIN_ROLE) {
-        _setRoyaltyAllowlistRegistry(_royaltyAllowlist);
+    function setOperatorAllowlistRegistry(address _operatorAllowlist) public onlyRole(DEFAULT_ADMIN_ROLE) {
+        _setOperatorAllowlistRegistry(_operatorAllowlist);
     }
 
-    function _setRoyaltyAllowlistRegistry(address _royaltyAllowlist) internal {
-        if (
-            !IERC165(_royaltyAllowlist).supportsInterface(
-                type(IRoyaltyAllowlist).interfaceId
-            )
-        ) {
-            revert RoyaltyEnforcementDoesNotImplementRequiredInterface();
+    function _setOperatorAllowlistRegistry(address _operatorAllowlist) internal {
+        if (!IERC165(_operatorAllowlist).supportsInterface(type(IOperatorAllowlist).interfaceId)) {
+            revert AllowlistDoesNotImplementIOperatorAllowlist();
         }
 
-        emit RoyaltyAllowlistRegistryUpdated(
-            address(royaltyAllowlist),
-            _royaltyAllowlist
-        );
-        royaltyAllowlist = IRoyaltyAllowlist(_royaltyAllowlist);
+        emit OperatorAllowlistRegistryUpdated(address(operatorAllowlist), _operatorAllowlist);
+        operatorAllowlist = IOperatorAllowlist(_operatorAllowlist);
     }
 
     modifier validateApproval(address targetApproval) {
         // Check for:
         // 1. approver is an EOA. Contract constructor is handled as transfers 'from' are blocked
         // 2. approver is address or bytecode is allowlisted
-        if (
-            msg.sender.code.length != 0 &&
-            !royaltyAllowlist.isAllowlisted(msg.sender)
-        ) {
+        if (msg.sender.code.length != 0 && !operatorAllowlist.isAllowlisted(msg.sender)) {
             revert ApproverNotInAllowlist(msg.sender);
         }
 
         // Check for:
         // 1. approval target is an EOA
         // 2. approval target address is Allowlisted or target address bytecode is Allowlisted
-        if (
-            targetApproval.code.length != 0 &&
-            !royaltyAllowlist.isAllowlisted(targetApproval)
-        ) {
+        if (targetApproval.code.length != 0 && !operatorAllowlist.isAllowlisted(targetApproval)) {
             revert ApproveTargetNotInAllowlist(targetApproval);
         }
         _;
@@ -87,23 +64,23 @@ abstract contract RoyaltyEnforced is
         // 1. caller is an EOA
         // 2. caller is Allowlisted or is the calling address bytecode is Allowlisted
         if (
-            msg.sender != tx.origin &&
-            !royaltyAllowlist.isAllowlisted(msg.sender)
+            msg.sender != tx.origin && // solhint-disable-line avoid-tx-origin
+            !operatorAllowlist.isAllowlisted(msg.sender)
         ) {
             revert CallerNotInAllowlist(msg.sender);
         }
 
         // Check for:
         // 1. from is an EOA
         // 2. from is Allowlisted or from address bytecode is Allowlisted
-        if (from.code.length != 0 && !royaltyAllowlist.isAllowlisted(from)) {
+        if (from.code.length != 0 && !operatorAllowlist.isAllowlisted(from)) {
             revert TransferFromNotInAllowlist(from);
         }
 
         // Check for:
         // 1. to is an EOA
         // 2. to is Allowlisted or to address bytecode is Allowlisted
-        if (to.code.length != 0 && !royaltyAllowlist.isAllowlisted(to)) {
+        if (to.code.length != 0 && !operatorAllowlist.isAllowlisted(to)) {
             revert TransferToNotInAllowlist(to);
         }
         _;

contracts/errors/Errors.sol

@@ -1,3 +1,4 @@
+//SPDX-License-Identifier: Apache 2.0
 pragma solidity ^0.8.0;
 
 interface IImmutableERC721Errors {
@@ -17,28 +18,25 @@ interface IImmutableERC721Errors {
     error IImmutableERC721NotOwnerOrOperator(uint256 tokenId);
 
     /// @dev Current token owner is not what was expected
-    error IImmutableERC721MismatchedTokenOwner(
-        uint256 tokenId,
-        address currentOwner
-    );
+    error IImmutableERC721MismatchedTokenOwner(uint256 tokenId, address currentOwner);
 }
 
-interface RoyaltyEnforcementErrors {
-    /// @dev Caller tried to mint an already burned token
-    error RoyaltyEnforcementDoesNotImplementRequiredInterface();
+interface OperatorAllowlistEnforcementErrors {
+    /// @dev Error thrown when the operatorAllowlist address does not implement the IOperatorAllowlist interface
+    error AllowlistDoesNotImplementIOperatorAllowlist();
 
-    /// @dev Error thrown when calling address is not Allowlisted
+    /// @dev Error thrown when calling address is not OperatorAllowlist
     error CallerNotInAllowlist(address caller);
 
-    /// @dev Error thrown when 'from' address is not Allowlisted
+    /// @dev Error thrown when 'from' address is not OperatorAllowlist
     error TransferFromNotInAllowlist(address from);
 
-    /// @dev Error thrown when 'to' address is not Allowlisted
+    /// @dev Error thrown when 'to' address is not OperatorAllowlist
     error TransferToNotInAllowlist(address to);
 
-    /// @dev Error thrown when approve target is not Allowlisted
+    /// @dev Error thrown when approve target is not OperatorAllowlist
     error ApproveTargetNotInAllowlist(address target);
 
-    /// @dev Error thrown when approve target is not Allowlisted
+    /// @dev Error thrown when approve target is not OperatorAllowlist
     error ApproverNotInAllowlist(address approver);
 }

contracts/mocks/MockDisguisedEOA.sol

@@ -10,11 +10,7 @@ contract MockDisguisedEOA {
         tokenAddress = _tokenAddress;
     }
 
-    function executeTransfer(
-        address from,
-        address recipient,
-        uint256 _tokenId
-    ) external {
+    function executeTransfer(address from, address recipient, uint256 _tokenId) external {
         tokenAddress.transferFrom(from, recipient, _tokenId);
     }
 }

contracts/mocks/MockFactory.sol

@@ -3,10 +3,7 @@ pragma solidity ^0.8.0;
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 
 contract MockFactory {
-    function computeAddress(
-        bytes32 salt,
-        bytes32 codeHash
-    ) public view returns (address) {
+    function computeAddress(bytes32 salt, bytes32 codeHash) public view returns (address) {
         return Create2.computeAddress(salt, codeHash);
     }