Marketplace V3 + Latest Plugin Pattern

contracts/extension/plugin/ContractMetadataLogic.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./ContractMetadataStorage.sol";
+import "../../extension/interface/IContractMetadata.sol";
+
+/**
+ *  @title   Contract Metadata
+ *  @notice  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
+ *           for you contract.
+ *           Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
+ */
+
+abstract contract ContractMetadataLogic is IContractMetadata {
+    /// @dev Returns the metadata URI of the contract.
+    function contractURI() public view returns (string memory) {
+        ContractMetadataStorage.Data storage data = ContractMetadataStorage.contractMetadataStorage();
+        return data.contractURI;
+    }
+
+    /**
+     *  @notice         Lets a contract admin set the URI for contract-level metadata.
+     *  @dev            Caller should be authorized to setup contractURI, e.g. contract admin.
+     *                  See {_canSetContractURI}.
+     *                  Emits {ContractURIUpdated Event}.
+     *
+     *  @param _uri     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     */
+    function setContractURI(string memory _uri) external override {
+        if (!_canSetContractURI()) {
+            revert("Not authorized");
+        }
+
+        _setupContractURI(_uri);
+    }
+
+    /// @dev Lets a contract admin set the URI for contract-level metadata.
+    function _setupContractURI(string memory _uri) internal {
+        ContractMetadataStorage.Data storage data = ContractMetadataStorage.contractMetadataStorage();
+        string memory prevURI = data.contractURI;
+        data.contractURI = _uri;
+
+        emit ContractURIUpdated(prevURI, _uri);
+    }
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual returns (bool);
+}

contracts/extension/plugin/ContractMetadataStorage.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library ContractMetadataStorage {
+    bytes32 public constant CONTRACT_METADATA_STORAGE_POSITION = keccak256("contract.metadata.storage");
+
+    struct Data {
+        string contractURI;
+    }
+
+    function contractMetadataStorage() internal pure returns (Data storage contractMetadataData) {
+        bytes32 position = CONTRACT_METADATA_STORAGE_POSITION;
+        assembly {
+            contractMetadataData.slot := position
+        }
+    }
+}

contracts/extension/plugin/ERC2771ContextUpgradeableLogic.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./ERC2771ContextStorage.sol";
+
+/**
+ * @dev Context variant with ERC2771 support.
+ */
+abstract contract ERC2771ContextUpgradeableLogic {
+    function __ERC2771Context_init(address[] memory trustedForwarder) internal {
+        __ERC2771Context_init_unchained(trustedForwarder);
+    }
+
+    function __ERC2771Context_init_unchained(address[] memory trustedForwarder) internal {
+        ERC2771ContextStorage.Data storage data = ERC2771ContextStorage.erc2771ContextStorage();
+
+        for (uint256 i = 0; i < trustedForwarder.length; i++) {
+            data._trustedForwarder[trustedForwarder[i]] = true;
+        }
+    }
+
+    function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
+        ERC2771ContextStorage.Data storage data = ERC2771ContextStorage.erc2771ContextStorage();
+        return data._trustedForwarder[forwarder];
+    }
+
+    function _msgSender() internal view virtual returns (address sender) {
+        if (isTrustedForwarder(msg.sender)) {
+            // The assembly code is more direct than the Solidity version using `abi.decode`.
+            assembly {
+                sender := shr(96, calldataload(sub(calldatasize(), 20)))
+            }
+        } else {
+            return msg.sender;
+        }
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        if (isTrustedForwarder(msg.sender)) {
+            return msg.data[:msg.data.length - 20];
+        } else {
+            return msg.data;
+        }
+    }
+}

contracts/extension/plugin/ERC2771ContextUpgradeableStorage.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library ERC2771ContextUpgradeableStorage {
+    bytes32 public constant ERC2771_CONTEXT_UPGRADEABLE_STORAGE_POSITION =
+        keccak256("erc2771.context.upgradeable.storage");
+
+    struct Data {
+        mapping(address => bool) _trustedForwarder;
+    }
+
+    function erc2771ContextUpgradeableStorage() internal pure returns (Data storage erc2771ContextData) {
+        bytes32 position = ERC2771_CONTEXT_UPGRADEABLE_STORAGE_POSITION;
+        assembly {
+            erc2771ContextData.slot := position
+        }
+    }
+}

contracts/extension/plugin/PlatformFeeLogic.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./PlatformFeeStorage.sol";
+import "../../extension/interface/IPlatformFee.sol";
+
+/**
+ *  @title   Platform Fee
+ *  @notice  Thirdweb's `PlatformFee` is a contract extension to be used with any base contract. It exposes functions for setting and reading
+ *           the recipient of platform fee and the platform fee basis points, and lets the inheriting contract perform conditional logic
+ *           that uses information about platform fees, if desired.
+ */
+
+abstract contract PlatformFeeLogic is IPlatformFee {
+    /// @dev Returns the platform fee recipient and bps.
+    function getPlatformFeeInfo() public view override returns (address, uint16) {
+        PlatformFeeStorage.Data storage data = PlatformFeeStorage.platformFeeStorage();
+        return (data.platformFeeRecipient, uint16(data.platformFeeBps));
+    }
+
+    /**
+     *  @notice         Updates the platform fee recipient and bps.
+     *  @dev            Caller should be authorized to set platform fee info.
+     *                  See {_canSetPlatformFeeInfo}.
+     *                  Emits {PlatformFeeInfoUpdated Event}; See {_setupPlatformFeeInfo}.
+     *
+     *  @param _platformFeeRecipient   Address to be set as new platformFeeRecipient.
+     *  @param _platformFeeBps         Updated platformFeeBps.
+     */
+    function setPlatformFeeInfo(address _platformFeeRecipient, uint256 _platformFeeBps) external override {
+        if (!_canSetPlatformFeeInfo()) {
+            revert("Not authorized");
+        }
+        _setupPlatformFeeInfo(_platformFeeRecipient, _platformFeeBps);
+    }
+
+    /// @dev Lets a contract admin update the platform fee recipient and bps
+    function _setupPlatformFeeInfo(address _platformFeeRecipient, uint256 _platformFeeBps) internal {
+        PlatformFeeStorage.Data storage data = PlatformFeeStorage.platformFeeStorage();
+        if (_platformFeeBps > 10_000) {
+            revert("Exceeds max bps");
+        }
+
+        data.platformFeeBps = uint16(_platformFeeBps);
+        data.platformFeeRecipient = _platformFeeRecipient;
+
+        emit PlatformFeeInfoUpdated(_platformFeeRecipient, _platformFeeBps);
+    }
+
+    /// @dev Returns whether platform fee info can be set in the given execution context.
+    function _canSetPlatformFeeInfo() internal view virtual returns (bool);
+}

contracts/extension/plugin/PlatformFeeStorage.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library PlatformFeeStorage {
+    bytes32 public constant PLATFORM_FEE_STORAGE_POSITION = keccak256("platform.fee.storage");
+
+    struct Data {
+        /// @dev The address that receives all platform fees from all sales.
+        address platformFeeRecipient;
+        /// @dev The % of primary sales collected as platform fees.
+        uint16 platformFeeBps;
+    }
+
+    function platformFeeStorage() internal pure returns (Data storage platformFeeData) {
+        bytes32 position = PLATFORM_FEE_STORAGE_POSITION;
+        assembly {
+            platformFeeData.slot := position
+        }
+    }
+}

contracts/extension/plugin/ReentrancyGuardLogic.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
+pragma solidity ^0.8.0;
+
+import "./ReentrancyGuardStorage.sol";
+
+/**
+ * @dev Contract module that helps prevent reentrant calls to a function.
+ *
+ * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
+ * available, which can be applied to functions to make sure there are no nested
+ * (reentrant) calls to them.
+ *
+ * Note that because there is a single `nonReentrant` guard, functions marked as
+ * `nonReentrant` may not call one another. This can be worked around by making
+ * those functions `private`, and then adding `external` `nonReentrant` entry
+ * points to them.
+ *
+ * TIP: If you would like to learn more about reentrancy and alternative ways
+ * to protect against it, check out our blog post
+ * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
+ */
+abstract contract ReentrancyGuardLogic {
+    // Booleans are more expensive than uint256 or any type that takes up a full
+    // word because each write operation emits an extra SLOAD to first read the
+    // slot's contents, replace the bits taken up by the boolean, and then write
+    // back. This is the compiler's defense against contract upgrades and
+    // pointer aliasing, and it cannot be disabled.
+
+    // The values being non-zero value makes deployment a bit more expensive,
+    // but in exchange the refund on every call to nonReentrant will be lower in
+    // amount. Since refunds are capped to a percentage of the total
+    // transaction's gas, it is best to keep them low in cases like this one, to
+    // increase the likelihood of the full refund coming into effect.
+    uint256 private constant _NOT_ENTERED = 1;
+    uint256 private constant _ENTERED = 2;
+
+    function __ReentrancyGuard_init() internal {
+        __ReentrancyGuard_init_unchained();
+    }
+
+    function __ReentrancyGuard_init_unchained() internal {
+        ReentrancyGuardStorage.Data storage data = ReentrancyGuardStorage.reentrancyGuardStorage();
+        data._status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and making it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        ReentrancyGuardStorage.Data storage data = ReentrancyGuardStorage.reentrancyGuardStorage();
+        // On the first call to nonReentrant, _notEntered will be true
+        require(data._status != _ENTERED, "ReentrancyGuard: reentrant call");
+
+        // Any calls to nonReentrant after this point will fail
+        data._status = _ENTERED;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        data._status = _NOT_ENTERED;
+    }
+}

contracts/extension/plugin/ReentrancyGuardStorage.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library ReentrancyGuardStorage {
+    bytes32 public constant REENTRANCY_GUARD_STORAGE_POSITION = keccak256("reentrancy.guard.storage");
+
+    struct Data {
+        uint256 _status;
+    }
+
+    function reentrancyGuardStorage() internal pure returns (Data storage reentrancyGuardData) {
+        bytes32 position = REENTRANCY_GUARD_STORAGE_POSITION;
+        assembly {
+            reentrancyGuardData.slot := position
+        }
+    }
+}