Forking over immutable OperatorAllowlistEnforced contract

Author: GWSzeto

dependecies/immutable/allowlist/IOperatorAllowlist.sol

@@ -0,0 +1,14 @@
+// Copyright Immutable Pty Ltd 2018 - 2023
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.24;
+
+/**
+ * @notice Required interface of an OperatorAllowlist compliant contract
+ */
+interface IOperatorAllowlist {
+    /**
+     * @notice Returns true if an address is Allowlisted false otherwise
+     *  @param target the address to be checked against the Allowlist
+     */
+    function isAllowlisted(address target) external view returns (bool);
+}

dependecies/immutable/allowlist/OperatorAllowlistEnforced.sol

@@ -0,0 +1,104 @@
+// Copyright Immutable Pty Ltd 2018 - 2023
+// SPDX-License-Identifier: Apache 2.0
+// slither-disable-start calls-loop
+pragma solidity ^0.8.24;
+
+// Allowlist Registry
+import {IOperatorAllowlist} from "./IOperatorAllowlist.sol";
+
+// Errors
+import {OperatorAllowlistEnforcementErrors} from "../errors/Errors.sol";
+
+interface IERC165 {
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+}
+
+/*
+    OperatorAllowlistEnforced is an abstract contract that token contracts can inherit in order to set the
+    address of the OperatorAllowlist registry that it will interface with, so that the token contract may
+    enable the restriction of approvals and transfers to allowlisted users.
+    OperatorAllowlistEnforced is not designed to be upgradeable or extended.
+*/
+
+abstract contract OperatorAllowlistEnforced is OperatorAllowlistEnforcementErrors {
+
+    ///     =====     Events         =====
+
+    /// @notice Emitted whenever the transfer Allowlist registry is updated
+    event OperatorAllowlistRegistryUpdated(address oldRegistry, address newRegistry);
+
+    ///     =====     Modifiers      =====
+
+    /**
+     * @notice Internal function to validate an approval, according to whether the target is an EOA or Allowlisted
+     * @param targetApproval the address of the approval target to be validated
+     */
+    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 && !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 && !operatorAllowlist.isAllowlisted(targetApproval)) {
+            revert ApproveTargetNotInAllowlist(targetApproval);
+        }
+        _;
+    }
+
+    /**
+     * @notice Internal function to validate a transfer, according to whether the calling address,
+     * from address and to address is an EOA or Allowlisted
+     * @param from the address of the from target to be validated
+     * @param to the address of the to target to be validated
+     */
+    modifier validateTransfer(address from, address to) {
+        // Check for:
+        // 1. caller is an EOA
+        // 2. caller is Allowlisted or is the calling address bytecode is Allowlisted
+        if (
+            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 && !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 && !operatorAllowlist.isAllowlisted(to)) {
+            revert TransferToNotInAllowlist(to);
+        }
+        _;
+    }
+
+    ///     =====  External functions  =====
+
+    /**
+     * @notice Internal function to set the operator allowlist the calling contract will interface with
+     * @param _operatorAllowlist the address of the Allowlist registry
+     */
+    function _setOperatorAllowlistRegistry(address _operatorAllowlist) internal {
+        if (!IERC165(_operatorAllowlist).supportsInterface(type(IOperatorAllowlist).interfaceId)) {
+            revert AllowlistDoesNotImplementIOperatorAllowlist();
+        }
+
+        emit OperatorAllowlistRegistryUpdated(address(operatorAllowlist), _operatorAllowlist);
+        operatorAllowlist = IOperatorAllowlist(_operatorAllowlist);
+    }
+
+}
+// slither-disable-end calls-loop

dependecies/immutable/errors/Errors.sol

@@ -0,0 +1,59 @@
+//SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.24;
+
+interface IImmutableERC721Errors {
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721TokenAlreadyBurned(uint256 tokenId);
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721SendingToZerothAddress();
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721MismatchedTransferLengths();
+
+    /// @dev Caller tried to mint a tokenid that is above the hybrid threshold
+    error IImmutableERC721IDAboveThreshold(uint256 tokenId);
+
+    /// @dev Caller is not approved or owner
+    error IImmutableERC721NotOwnerOrOperator(uint256 tokenId);
+
+    /// @dev Current token owner is not what was expected
+    error IImmutableERC721MismatchedTokenOwner(uint256 tokenId, address currentOwner);
+
+    /// @dev Signer is zeroth address
+    error SignerCannotBeZerothAddress();
+
+    /// @dev Deadline exceeded for permit
+    error PermitExpired();
+
+    /// @dev Derived signature is invalid (EIP721 and EIP1271)
+    error InvalidSignature();
+}
+
+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 OperatorAllowlist
+    error CallerNotInAllowlist(address caller);
+
+    /// @dev Error thrown when 'from' address is not OperatorAllowlist
+    error TransferFromNotInAllowlist(address from);
+
+    /// @dev Error thrown when 'to' address is not OperatorAllowlist
+    error TransferToNotInAllowlist(address to);
+
+    /// @dev Error thrown when approve target is not OperatorAllowlist
+    error ApproveTargetNotInAllowlist(address target);
+
+    /// @dev Error thrown when approve target is not OperatorAllowlist
+    error ApproverNotInAllowlist(address approver);
+}
+
+interface IImmutableERC1155Errors {
+    /// @dev Deadline exceeded for permit
+    error PermitExpired();
+
+    /// @dev Derived signature is invalid (EIP721 and EIP1271)
+    error InvalidSignature();
+}