Add extensions: OpenSea operator filterers

Author: nkrishang

contracts/extension/DefaultOperatorFilterer.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache 2.0
+// Credits: OpenSea
+pragma solidity ^0.8.0;
+
+import { OperatorFilterer } from "./OperatorFilterer.sol";
+
+contract DefaultOperatorFilterer is OperatorFilterer {
+    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
+
+    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
+}

contracts/extension/OperatorFilterer.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache 2.0
+// Credits: OpenSea
+pragma solidity ^0.8.0;
+
+import { IOperatorFilterRegistry } from "./interface/IOperatorFilterRegistry.sol";
+
+contract OperatorFilterer {
+    error OperatorNotAllowed(address operator);
+
+    IOperatorFilterRegistry constant OPERATOR_FILTERER_REGISTRY =
+        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
+
+    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
+        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
+        // will not revert, but the contract will need to be registered with the registry once it is deployed in
+        // order for the modifier to filter addresses.
+        if (address(OPERATOR_FILTERER_REGISTRY).code.length > 0) {
+            if (subscribe) {
+                OPERATOR_FILTERER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
+            } else {
+                if (subscriptionOrRegistrantToCopy != address(0)) {
+                    OPERATOR_FILTERER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
+                } else {
+                    OPERATOR_FILTERER_REGISTRY.register(address(this));
+                }
+            }
+        }
+    }
+
+    modifier onlyAllowedOperator() virtual {
+        // Check registry code length to facilitate testing in environments without a deployed registry.
+        if (address(OPERATOR_FILTERER_REGISTRY).code.length > 0) {
+            if (!OPERATOR_FILTERER_REGISTRY.isOperatorAllowed(address(this), msg.sender)) {
+                revert OperatorNotAllowed(msg.sender);
+            }
+        }
+        _;
+    }
+}

contracts/extension/interface/IOperatorFilterRegistry.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache 2.0
+// Credits: OpenSea
+pragma solidity ^0.8.0;
+
+interface IOperatorFilterRegistry {
+    function isOperatorAllowed(address registrant, address operator) external returns (bool);
+
+    function register(address registrant) external;
+
+    function registerAndSubscribe(address registrant, address subscription) external;
+
+    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
+
+    function updateOperator(
+        address registrant,
+        address operator,
+        bool filtered
+    ) external;
+
+    function updateOperators(
+        address registrant,
+        address[] calldata operators,
+        bool filtered
+    ) external;
+
+    function updateCodeHash(
+        address registrant,
+        bytes32 codehash,
+        bool filtered
+    ) external;
+
+    function updateCodeHashes(
+        address registrant,
+        bytes32[] calldata codeHashes,
+        bool filtered
+    ) external;
+
+    function subscribe(address registrant, address registrantToSubscribe) external;
+
+    function unsubscribe(address registrant, bool copyExistingEntries) external;
+
+    function subscriptionOf(address addr) external returns (address registrant);
+
+    function subscribers(address registrant) external returns (address[] memory);
+
+    function subscriberAt(address registrant, uint256 index) external returns (address);
+
+    function copyEntriesOf(address registrant, address registrantToCopy) external;
+
+    function isOperatorFiltered(address registrant, address operator) external returns (bool);
+
+    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
+
+    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
+
+    function filteredOperators(address addr) external returns (address[] memory);
+
+    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
+
+    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
+
+    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
+
+    function isRegistered(address addr) external returns (bool);
+
+    function codeHashOf(address addr) external returns (bytes32);
+}

docs/DefaultOperatorFilterer.md

@@ -0,0 +1,31 @@
+# DefaultOperatorFilterer
+
+
+
+
+
+
+
+
+
+
+
+## Errors
+
+### OperatorNotAllowed
+
+```solidity
+error OperatorNotAllowed(address operator)
+```
+
+
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| operator | address | undefined |
+
+