@rarible/external-contracts 3.11.4

package/contracts/extension/OperatorFilterer.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IOperatorFilterRegistry.sol";
+import "./OperatorFilterToggle.sol";
+
+/**
+ * @title  OperatorFilterer
+ * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
+ *         registrant's entries in the OperatorFilterRegistry.
+ * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
+ *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
+ *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
+ */
+
+abstract contract OperatorFilterer is OperatorFilterToggle {
+    error OperatorNotAllowed(address operator);
+
+    IOperatorFilterRegistry public constant OPERATOR_FILTER_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.
+        _register(subscriptionOrRegistrantToCopy, subscribe);
+    }
+
+    modifier onlyAllowedOperator(address from) virtual {
+        // Allow spending tokens from addresses with balance
+        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
+        // from an EOA.
+        if (from != msg.sender) {
+            _checkFilterOperator(msg.sender);
+        }
+        _;
+    }
+
+    modifier onlyAllowedOperatorApproval(address operator) virtual {
+        _checkFilterOperator(operator);
+        _;
+    }
+
+    function _checkFilterOperator(address operator) internal view virtual {
+        // Check registry code length to facilitate testing in environments without a deployed registry.
+        if (operatorRestriction) {
+            if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
+                if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
+                    revert OperatorNotAllowed(operator);
+                }
+            }
+        }
+    }
+
+    function _register(address subscriptionOrRegistrantToCopy, bool subscribe) internal {
+        // Is the registry deployed?
+        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
+            // Is the subscription contract deployed?
+            if (address(subscriptionOrRegistrantToCopy).code.length > 0) {
+                // Do we want to subscribe?
+                if (subscribe) {
+                    OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
+                } else {
+                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
+                }
+            } else {
+                OPERATOR_FILTER_REGISTRY.register(address(this));
+            }
+        }
+    }
+}

package/contracts/extension/OperatorFiltererUpgradeable.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IOperatorFilterRegistry.sol";
+import "./OperatorFilterToggle.sol";
+
+abstract contract OperatorFiltererUpgradeable is OperatorFilterToggle {
+    error OperatorNotAllowed(address operator);
+
+    IOperatorFilterRegistry constant OPERATOR_FILTER_REGISTRY =
+        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
+
+    function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) internal {
+        // 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.
+        _register(subscriptionOrRegistrantToCopy, subscribe);
+    }
+
+    modifier onlyAllowedOperator(address from) virtual {
+        // Check registry code length to facilitate testing in environments without a deployed registry.
+        if (operatorRestriction) {
+            if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
+                // Allow spending tokens from addresses with balance
+                // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
+                // from an EOA.
+                if (from == msg.sender) {
+                    _;
+                    return;
+                }
+                if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), msg.sender)) {
+                    revert OperatorNotAllowed(msg.sender);
+                }
+            }
+        }
+        _;
+    }
+
+    modifier onlyAllowedOperatorApproval(address operator) virtual {
+        // Check registry code length to facilitate testing in environments without a deployed registry.
+        if (operatorRestriction) {
+            if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
+                if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
+                    revert OperatorNotAllowed(operator);
+                }
+            }
+        }
+        _;
+    }
+
+    function _register(address subscriptionOrRegistrantToCopy, bool subscribe) internal {
+        // Is the registry deployed?
+        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
+            // Is the subscription contract deployed?
+            if (address(subscriptionOrRegistrantToCopy).code.length > 0) {
+                // Do we want to subscribe?
+                if (subscribe) {
+                    OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
+                } else {
+                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
+                }
+            } else {
+                OPERATOR_FILTER_REGISTRY.register(address(this));
+            }
+        }
+    }
+}

package/contracts/extension/Ownable.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IOwnable.sol";
+
+/**
+ *  @title   Ownable
+ *  @notice  Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading
+ *           who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses
+ *           information about who the contract's owner is.
+ */
+
+abstract contract Ownable is IOwnable {
+    /// @dev The sender is not authorized to perform the action
+    error OwnableUnauthorized();
+
+    /// @dev Owner of the contract (purpose: OpenSea compatibility)
+    address private _owner;
+
+    /// @dev Reverts if caller is not the owner.
+    modifier onlyOwner() {
+        if (msg.sender != _owner) {
+            revert OwnableUnauthorized();
+        }
+        _;
+    }
+
+    /**
+     *  @notice Returns the owner of the contract.
+     */
+    function owner() public view override returns (address) {
+        return _owner;
+    }
+
+    /**
+     *  @notice Lets an authorized wallet set a new owner for the contract.
+     *  @param _newOwner The address to set as the new owner of the contract.
+     */
+    function setOwner(address _newOwner) external override {
+        if (!_canSetOwner()) {
+            revert OwnableUnauthorized();
+        }
+        _setupOwner(_newOwner);
+    }
+
+    /// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
+    function _setupOwner(address _newOwner) internal {
+        address _prevOwner = _owner;
+        _owner = _newOwner;
+
+        emit OwnerUpdated(_prevOwner, _newOwner);
+    }
+
+    /// @dev Returns whether owner can be set in the given execution context.
+    function _canSetOwner() internal view virtual returns (bool);
+}

package/contracts/extension/Permissions.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IPermissions.sol";
+import "../lib/Strings.sol";
+
+/**
+ *  @title   Permissions
+ *  @dev     This contracts provides extending-contracts with role-based access control mechanisms
+ */
+contract Permissions is IPermissions {
+    /// @dev The `account` is missing a role.
+    error PermissionsUnauthorizedAccount(address account, bytes32 neededRole);
+
+    /// @dev The `account` already is a holder of `role`
+    error PermissionsAlreadyGranted(address account, bytes32 role);
+
+    /// @dev Invalid priviledge to revoke
+    error PermissionsInvalidPermission(address expected, address actual);
+
+    /// @dev Map from keccak256 hash of a role => a map from address => whether address has role.
+    mapping(bytes32 => mapping(address => bool)) private _hasRole;
+
+    /// @dev Map from keccak256 hash of a role to role admin. See {getRoleAdmin}.
+    mapping(bytes32 => bytes32) private _getRoleAdmin;
+
+    /// @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, msg.sender);
+        _;
+    }
+
+    /**
+     *  @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) {
+        return _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) {
+        if (!_hasRole[role][address(0)]) {
+            return _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) {
+        return _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 {
+        _checkRole(_getRoleAdmin[role], msg.sender);
+        if (_hasRole[role][account]) {
+            revert PermissionsAlreadyGranted(account, role);
+        }
+        _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 {
+        _checkRole(_getRoleAdmin[role], msg.sender);
+        _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 (msg.sender != account) {
+            revert PermissionsInvalidPermission(msg.sender, account);
+        }
+        _revokeRole(role, account);
+    }
+
+    /// @dev Sets `adminRole` as `role`'s admin role.
+    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
+        bytes32 previousAdminRole = _getRoleAdmin[role];
+        _getRoleAdmin[role] = adminRole;
+        emit RoleAdminChanged(role, previousAdminRole, adminRole);
+    }
+
+    /// @dev Sets up `role` for `account`
+    function _setupRole(bytes32 role, address account) internal virtual {
+        _hasRole[role][account] = true;
+        emit RoleGranted(role, account, msg.sender);
+    }
+
+    /// @dev Revokes `role` from `account`
+    function _revokeRole(bytes32 role, address account) internal virtual {
+        _checkRole(role, account);
+        delete _hasRole[role][account];
+        emit RoleRevoked(role, account, msg.sender);
+    }
+
+    /// @dev Checks `role` for `account`. Reverts with a message including the required role.
+    function _checkRole(bytes32 role, address account) internal view virtual {
+        if (!_hasRole[role][account]) {
+            revert PermissionsUnauthorizedAccount(account, role);
+        }
+    }
+
+    /// @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 PermissionsUnauthorizedAccount(account, role);
+        }
+    }
+}

package/contracts/extension/PermissionsEnumerable.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IPermissionsEnumerable.sol";
+import "./Permissions.sol";
+
+/**
+ *  @title   PermissionsEnumerable
+ *  @dev     This contracts provides extending-contracts with role-based access control mechanisms.
+ *           Also provides interfaces to view all members with a given role, and total count of members.
+ */
+contract PermissionsEnumerable is IPermissionsEnumerable, Permissions {
+    /**
+     *  @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;
+    }
+
+    /// @dev map from keccak256 hash of a role to its members' data. See {RoleMembers}.
+    mapping(bytes32 => RoleMembers) private roleMembers;
+
+    /**
+     *  @notice         Returns the role-member from a list of members for a role,
+     *                  at a given index.
+     *  @dev            Returns `member` who has `role`, at `index` of role-members list.
+     *                  See struct {RoleMembers}, and mapping {roleMembers}
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *  @param index    Index in list of current members for the role.
+     *
+     *  @return member  Address of account that has `role`
+     */
+    function getRoleMember(bytes32 role, uint256 index) external view override returns (address member) {
+        uint256 currentIndex = roleMembers[role].index;
+        uint256 check;
+
+        for (uint256 i = 0; i < currentIndex; i += 1) {
+            if (roleMembers[role].members[i] != address(0)) {
+                if (check == index) {
+                    member = roleMembers[role].members[i];
+                    return member;
+                }
+                check += 1;
+            } else if (hasRole(role, address(0)) && i == roleMembers[role].indexOf[address(0)]) {
+                check += 1;
+            }
+        }
+    }
+
+    /**
+     *  @notice         Returns total number of accounts that have a role.
+     *  @dev            Returns `count` of accounts that have `role`.
+     *                  See struct {RoleMembers}, and mapping {roleMembers}
+     *
+     *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     *
+     *  @return count   Total number of accounts that have `role`
+     */
+    function getRoleMemberCount(bytes32 role) external view override returns (uint256 count) {
+        uint256 currentIndex = roleMembers[role].index;
+
+        for (uint256 i = 0; i < currentIndex; i += 1) {
+            if (roleMembers[role].members[i] != address(0)) {
+                count += 1;
+            }
+        }
+        if (hasRole(role, address(0))) {
+            count += 1;
+        }
+    }
+
+    /// @dev Revokes `role` from `account`, and removes `account` from {roleMembers}
+    ///      See {_removeMember}
+    function _revokeRole(bytes32 role, address account) internal override {
+        super._revokeRole(role, account);
+        _removeMember(role, account);
+    }
+
+    /// @dev Grants `role` to `account`, and adds `account` to {roleMembers}
+    ///      See {_addMember}
+    function _setupRole(bytes32 role, address account) internal override {
+        super._setupRole(role, account);
+        _addMember(role, account);
+    }
+
+    /// @dev adds `account` to {roleMembers}, for `role`
+    function _addMember(bytes32 role, address account) internal {
+        uint256 idx = roleMembers[role].index;
+        roleMembers[role].index += 1;
+
+        roleMembers[role].members[idx] = account;
+        roleMembers[role].indexOf[account] = idx;
+    }
+
+    /// @dev removes `account` from {roleMembers}, for `role`
+    function _removeMember(bytes32 role, address account) internal {
+        uint256 idx = roleMembers[role].indexOf[account];
+
+        delete roleMembers[role].members[idx];
+        delete roleMembers[role].indexOf[account];
+    }
+}

package/contracts/extension/PlatformFee.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./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 PlatformFee is IPlatformFee {
+    /// @dev The sender is not authorized to perform the action
+    error PlatformFeeUnauthorized();
+
+    /// @dev The recipient is invalid
+    error PlatformFeeInvalidRecipient(address recipient);
+
+    /// @dev The fee bps exceeded the max value
+    error PlatformFeeExceededMaxFeeBps(uint256 max, uint256 actual);
+
+    /// @dev The address that receives all platform fees from all sales.
+    address private platformFeeRecipient;
+
+    /// @dev The % of primary sales collected as platform fees.
+    uint16 private platformFeeBps;
+
+    /// @dev Fee type variants: percentage fee and flat fee
+    PlatformFeeType private platformFeeType;
+
+    /// @dev The flat amount collected by the contract as fees on primary sales.
+    uint256 private flatPlatformFee;
+
+    /// @dev Returns the platform fee recipient and bps.
+    function getPlatformFeeInfo() public view override returns (address, uint16) {
+        return (platformFeeRecipient, uint16(platformFeeBps));
+    }
+
+    /// @dev Returns the platform fee bps and recipient.
+    function getFlatPlatformFeeInfo() public view returns (address, uint256) {
+        return (platformFeeRecipient, flatPlatformFee);
+    }
+
+    /// @dev Returns the platform fee type.
+    function getPlatformFeeType() public view returns (PlatformFeeType) {
+        return platformFeeType;
+    }
+
+    /**
+     *  @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 PlatformFeeUnauthorized();
+        }
+        _setupPlatformFeeInfo(_platformFeeRecipient, _platformFeeBps);
+    }
+
+    /// @dev Sets the platform fee recipient and bps
+    function _setupPlatformFeeInfo(address _platformFeeRecipient, uint256 _platformFeeBps) internal {
+        if (_platformFeeBps > 10_000) {
+            revert PlatformFeeExceededMaxFeeBps(10_000, _platformFeeBps);
+        }
+        if (_platformFeeRecipient == address(0)) {
+            revert PlatformFeeInvalidRecipient(_platformFeeRecipient);
+        }
+
+        platformFeeBps = uint16(_platformFeeBps);
+        platformFeeRecipient = _platformFeeRecipient;
+
+        emit PlatformFeeInfoUpdated(_platformFeeRecipient, _platformFeeBps);
+    }
+
+    /// @notice Lets a module admin set a flat fee on primary sales.
+    function setFlatPlatformFeeInfo(address _platformFeeRecipient, uint256 _flatFee) external {
+        if (!_canSetPlatformFeeInfo()) {
+            revert PlatformFeeUnauthorized();
+        }
+
+        _setupFlatPlatformFeeInfo(_platformFeeRecipient, _flatFee);
+    }
+
+    /// @dev Sets a flat fee on primary sales.
+    function _setupFlatPlatformFeeInfo(address _platformFeeRecipient, uint256 _flatFee) internal {
+        flatPlatformFee = _flatFee;
+        platformFeeRecipient = _platformFeeRecipient;
+
+        emit FlatPlatformFeeUpdated(_platformFeeRecipient, _flatFee);
+    }
+
+    /// @notice Lets a module admin set platform fee type.
+    function setPlatformFeeType(PlatformFeeType _feeType) external {
+        if (!_canSetPlatformFeeInfo()) {
+            revert PlatformFeeUnauthorized();
+        }
+        _setupPlatformFeeType(_feeType);
+    }
+
+    /// @dev Sets platform fee type.
+    function _setupPlatformFeeType(PlatformFeeType _feeType) internal {
+        platformFeeType = _feeType;
+
+        emit PlatformFeeTypeUpdated(_feeType);
+    }
+
+    /// @dev Returns whether platform fee info can be set in the given execution context.
+    function _canSetPlatformFeeInfo() internal view virtual returns (bool);
+}

package/contracts/extension/PrimarySale.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IPrimarySale.sol";
+
+/**
+ *  @title   Primary Sale
+ *  @notice  Thirdweb's `PrimarySale` is a contract extension to be used with any base contract. It exposes functions for setting and reading
+ *           the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about
+ *           primary sales, if desired.
+ */
+
+abstract contract PrimarySale is IPrimarySale {
+    /// @dev The sender is not authorized to perform the action
+    error PrimarySaleUnauthorized();
+
+    /// @dev The recipient is invalid
+    error PrimarySaleInvalidRecipient(address recipient);
+
+    /// @dev The address that receives all primary sales value.
+    address private recipient;
+
+    /// @dev Returns primary sale recipient address.
+    function primarySaleRecipient() public view override returns (address) {
+        return recipient;
+    }
+
+    /**
+     *  @notice         Updates primary sale recipient.
+     *  @dev            Caller should be authorized to set primary sales info.
+     *                  See {_canSetPrimarySaleRecipient}.
+     *                  Emits {PrimarySaleRecipientUpdated Event}; See {_setupPrimarySaleRecipient}.
+     *
+     *  @param _saleRecipient   Address to be set as new recipient of primary sales.
+     */
+    function setPrimarySaleRecipient(address _saleRecipient) external override {
+        if (!_canSetPrimarySaleRecipient()) {
+            revert PrimarySaleUnauthorized();
+        }
+        _setupPrimarySaleRecipient(_saleRecipient);
+    }
+
+    /// @dev Lets a contract admin set the recipient for all primary sales.
+    function _setupPrimarySaleRecipient(address _saleRecipient) internal {
+        if (_saleRecipient == address(0)) {
+            revert PrimarySaleInvalidRecipient(_saleRecipient);
+        }
+
+        recipient = _saleRecipient;
+        emit PrimarySaleRecipientUpdated(_saleRecipient);
+    }
+
+    /// @dev Returns whether primary sale recipient can be set in the given execution context.
+    function _canSetPrimarySaleRecipient() internal view virtual returns (bool);
+}