@rarible/external-contracts 3.11.4

package/contracts/extension/plugin/PermissionsEnumerableStorage.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IPermissionsEnumerable.sol";
+
+/**
+ *  @author  thirdweb.com
+ */
+library PermissionsEnumerableStorage {
+    /// @custom:storage-location erc7201:permissions.enumerable.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("permissions.enumerable.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant PERMISSIONS_ENUMERABLE_STORAGE_POSITION =
+        0x1ea2ed6cf13bfad376ba49bede85b663fef0b40eac197c5ac8e6f92ec4076100;
+
+    /**
+     *  @notice A data structure to store data of members for a given role.
+     *
+     *  @param index    Current index in the list of accounts that have a role.
+     *  @param members  map from index => address of account that has a role
+     *  @param indexOf  map from address => index which the account has.
+     */
+    struct RoleMembers {
+        uint256 index;
+        mapping(uint256 => address) members;
+        mapping(address => uint256) indexOf;
+    }
+
+    struct Data {
+        /// @dev map from keccak256 hash of a role to its members' data. See {RoleMembers}.
+        mapping(bytes32 => RoleMembers) roleMembers;
+    }
+
+    function permissionsEnumerableStorage() internal pure returns (Data storage permissionsEnumerableData) {
+        bytes32 position = PERMISSIONS_ENUMERABLE_STORAGE_POSITION;
+        assembly {
+            permissionsEnumerableData.slot := position
+        }
+    }
+}

package/contracts/extension/plugin/PermissionsLogic.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IPermissions.sol";
+import "./PermissionsStorage.sol";
+import "../../lib/Strings.sol";
+
+/**
+ *  @author  thirdweb.com
+ *
+ *  @title   Permissions
+ *  @dev     This contracts provides extending-contracts with role-based access control mechanisms
+ */
+contract PermissionsLogic is IPermissions {
+    /// @dev Default admin role for all roles. Only accounts with this role can grant/revoke other roles.
+    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
+
+    /// @dev Modifier that checks if an account has the specified role; reverts otherwise.
+    modifier onlyRole(bytes32 role) {
+        _checkRole(role, _msgSender());
+        _;
+    }
+
+    /**
+     *  @notice         Checks whether an account has a particular role.
+     *  @dev            Returns `true` if `account` has been granted `role`.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param account  Address of the account for which the role is being checked.
+     */
+    function hasRole(bytes32 role, address account) public view override returns (bool) {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        return data._hasRole[role][account];
+    }
+
+    /**
+     *  @notice         Checks whether an account has a particular role;
+     *                  role restrictions can be swtiched on and off.
+     *
+     *  @dev            Returns `true` if `account` has been granted `role`.
+     *                  Role restrictions can be swtiched on and off:
+     *                      - If address(0) has ROLE, then the ROLE restrictions
+     *                        don't apply.
+     *                      - If address(0) does not have ROLE, then the ROLE
+     *                        restrictions will apply.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param account  Address of the account for which the role is being checked.
+     */
+    function hasRoleWithSwitch(bytes32 role, address account) public view returns (bool) {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        if (!data._hasRole[role][address(0)]) {
+            return data._hasRole[role][account];
+        }
+
+        return true;
+    }
+
+    /**
+     *  @notice         Returns the admin role that controls the specified role.
+     *  @dev            See {grantRole} and {revokeRole}.
+     *                  To change a role's admin, use {_setRoleAdmin}.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     */
+    function getRoleAdmin(bytes32 role) external view override returns (bytes32) {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        return data._getRoleAdmin[role];
+    }
+
+    /**
+     *  @notice         Grants a role to an account, if not previously granted.
+     *  @dev            Caller must have admin role for the `role`.
+     *                  Emits {RoleGranted Event}.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param account  Address of the account to which the role is being granted.
+     */
+    function grantRole(bytes32 role, address account) public virtual override {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        _checkRole(data._getRoleAdmin[role], _msgSender());
+        if (data._hasRole[role][account]) {
+            revert("Can only grant to non holders");
+        }
+        _setupRole(role, account);
+    }
+
+    /**
+     *  @notice         Revokes role from an account.
+     *  @dev            Caller must have admin role for the `role`.
+     *                  Emits {RoleRevoked Event}.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param account  Address of the account from which the role is being revoked.
+     */
+    function revokeRole(bytes32 role, address account) public virtual override {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        _checkRole(data._getRoleAdmin[role], _msgSender());
+        _revokeRole(role, account);
+    }
+
+    /**
+     *  @notice         Revokes role from the account.
+     *  @dev            Caller must have the `role`, with caller being the same as `account`.
+     *                  Emits {RoleRevoked Event}.
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param account  Address of the account from which the role is being revoked.
+     */
+    function renounceRole(bytes32 role, address account) public virtual override {
+        if (_msgSender() != account) {
+            revert("Can only renounce for self");
+        }
+        _revokeRole(role, account);
+    }
+
+    /// @dev Sets `adminRole` as `role`'s admin role.
+    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        bytes32 previousAdminRole = data._getRoleAdmin[role];
+        data._getRoleAdmin[role] = adminRole;
+        emit RoleAdminChanged(role, previousAdminRole, adminRole);
+    }
+
+    /// @dev Sets up `role` for `account`
+    function _setupRole(bytes32 role, address account) internal virtual {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        data._hasRole[role][account] = true;
+        emit RoleGranted(role, account, _msgSender());
+    }
+
+    /// @dev Revokes `role` from `account`
+    function _revokeRole(bytes32 role, address account) internal virtual {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        _checkRole(role, account);
+        delete data._hasRole[role][account];
+        emit RoleRevoked(role, account, _msgSender());
+    }
+
+    /// @dev Checks `role` for `account`. Reverts with a message including the required role.
+    function _checkRole(bytes32 role, address account) internal view virtual {
+        PermissionsStorage.Data storage data = PermissionsStorage.permissionsStorage();
+        if (!data._hasRole[role][account]) {
+            revert(
+                string(
+                    abi.encodePacked(
+                        "Permissions: account ",
+                        Strings.toHexString(uint160(account), 20),
+                        " is missing role ",
+                        Strings.toHexString(uint256(role), 32)
+                    )
+                )
+            );
+        }
+    }
+
+    /// @dev Checks `role` for `account`. Reverts with a message including the required role.
+    function _checkRoleWithSwitch(bytes32 role, address account) internal view virtual {
+        if (!hasRoleWithSwitch(role, account)) {
+            revert(
+                string(
+                    abi.encodePacked(
+                        "Permissions: account ",
+                        Strings.toHexString(uint160(account), 20),
+                        " is missing role ",
+                        Strings.toHexString(uint256(role), 32)
+                    )
+                )
+            );
+        }
+    }
+
+    function _msgSender() internal view virtual returns (address sender) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}

package/contracts/extension/plugin/PermissionsStorage.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  @author  thirdweb.com
+ */
+library PermissionsStorage {
+    /// @custom:storage-location erc7201:permissions.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("permissions.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant PERMISSIONS_STORAGE_POSITION =
+        0x0a7b0f5c59907924802379ebe98cdc23e2ee7820f63d30126e10b3752010e500;
+
+    struct Data {
+        /// @dev Map from keccak256 hash of a role => a map from address => whether address has role.
+        mapping(bytes32 => mapping(address => bool)) _hasRole;
+        /// @dev Map from keccak256 hash of a role to role admin. See {getRoleAdmin}.
+        mapping(bytes32 => bytes32) _getRoleAdmin;
+    }
+
+    function permissionsStorage() internal pure returns (Data storage permissionsData) {
+        bytes32 position = PERMISSIONS_STORAGE_POSITION;
+        assembly {
+            permissionsData.slot := position
+        }
+    }
+}

package/contracts/extension/plugin/PlatformFeeLogic.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./PlatformFeeStorage.sol";
+import "../interface/IPlatformFee.sol";
+
+/**
+ *  @author  thirdweb.com
+ *
+ *  @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);
+}

package/contracts/extension/plugin/PlatformFeeStorage.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  @author  thirdweb.com
+ */
+library PlatformFeeStorage {
+    /// @custom:storage-location erc7201:platform.fee.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("platform.fee.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant PLATFORM_FEE_STORAGE_POSITION =
+        0xc0c34308b4a2f4c5ee9af8ba82541cfb3c33b076d1fd05c65f9ce7060c64c400;
+
+    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
+        }
+    }
+}

package/contracts/extension/plugin/PluginMap.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/plugin/IPluginMap.sol";
+import "../../external-deps/openzeppelin/utils/EnumerableSet.sol";
+
+/**
+ *  @author  thirdweb.com
+ */
+contract PluginMap is IPluginMap {
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    EnumerableSet.Bytes32Set private allSelectors;
+
+    mapping(address => EnumerableSet.Bytes32Set) private selectorsForPlugin;
+    mapping(bytes4 => Plugin) private pluginForSelector;
+
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(Plugin[] memory _pluginsToAdd) {
+        uint256 len = _pluginsToAdd.length;
+        for (uint256 i = 0; i < len; i += 1) {
+            _setPlugin(_pluginsToAdd[i]);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev View address of the plugged-in functionality contract for a given function signature.
+    function getPluginForFunction(bytes4 _selector) public view returns (address) {
+        address _pluginAddress = pluginForSelector[_selector].pluginAddress;
+        require(_pluginAddress != address(0), "Map: No plugin available for selector");
+
+        return _pluginAddress;
+    }
+
+    /// @dev View all funtionality as list of function signatures.
+    function getAllFunctionsOfPlugin(address _pluginAddress) external view returns (bytes4[] memory registered) {
+        uint256 len = selectorsForPlugin[_pluginAddress].length();
+        registered = new bytes4[](len);
+
+        for (uint256 i = 0; i < len; i += 1) {
+            registered[i] = bytes4(selectorsForPlugin[_pluginAddress].at(i));
+        }
+    }
+
+    /// @dev View all funtionality existing on the contract.
+    function getAllPlugins() external view returns (Plugin[] memory _plugins) {
+        uint256 len = allSelectors.length();
+        _plugins = new Plugin[](len);
+
+        for (uint256 i = 0; i < len; i += 1) {
+            bytes4 selector = bytes4(allSelectors.at(i));
+            _plugins[i] = pluginForSelector[selector];
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Add functionality to the contract.
+    function _setPlugin(Plugin memory _plugin) internal {
+        require(allSelectors.add(bytes32(_plugin.functionSelector)), "Map: Selector exists");
+        require(
+            _plugin.functionSelector == bytes4(keccak256(abi.encodePacked(_plugin.functionSignature))),
+            "Map: Incorrect selector"
+        );
+
+        pluginForSelector[_plugin.functionSelector] = _plugin;
+        selectorsForPlugin[_plugin.pluginAddress].add(bytes32(_plugin.functionSelector));
+
+        emit PluginSet(_plugin.functionSelector, _plugin.functionSignature, _plugin.pluginAddress);
+    }
+}

package/contracts/extension/plugin/ReentrancyGuardLogic.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+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;
+    }
+}

package/contracts/extension/plugin/ReentrancyGuardStorage.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+library ReentrancyGuardStorage {
+    /// @custom:storage-location erc7201:reentrancy.guard.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("reentrancy.guard.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant REENTRANCY_GUARD_STORAGE_POSITION =
+        0x1d281c488dae143b6ea4122e80c65059929950b9c32f17fc57be22089d9c3b00;
+
+    struct Data {
+        uint256 _status;
+    }
+
+    function reentrancyGuardStorage() internal pure returns (Data storage reentrancyGuardData) {
+        bytes32 position = REENTRANCY_GUARD_STORAGE_POSITION;
+        assembly {
+            reentrancyGuardData.slot := position
+        }
+    }
+}