ETH Price: $3,520.67 (+0.77%)

Contract

0x47f690ad0168B6E3476B59A15a5dFe7adb8E34bc
 

Overview

ETH Balance

0 ETH

ETH Value

$0.00

Sponsored

Transaction Hash
Method
Block
From
To
Value
0x608060401185151372024-04-09 2:17:3166 days ago1712629051IN
 Create: ERC721EditionsDFS
0 ETH0.000336560.06496114

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ERC721EditionsDFS

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
Yes with 1 runs

Other Settings:
default evmVersion
File 1 of 40 : ERC721EditionsDFS.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "./interfaces/IERC721EditionsDFS.sol";
import "./ERC721Base.sol";
import "../utils/Ownable.sol";
import "../metadata/interfaces/IMetadataRenderer.sol";
import "../metadata/interfaces/IEditionsMetadataRenderer.sol";
import "../auction/interfaces/IAuctionManager.sol";
import "./interfaces/IEditionCollection.sol";

import "../tokenManager/interfaces/IPostTransfer.sol";
import "../tokenManager/interfaces/IPostBurn.sol";
import "../tokenManager/interfaces/ITokenManagerEditions.sol";
import "./interfaces/IERC721EditionMint.sol";
import "./MarketplaceFilterer/MarketplaceFiltererAbridged.sol";
import "../utils/ERC721/ERC721Upgradeable.sol";
import "../mint/interfaces/IAbridgedMintVector.sol";
import "../mint/mechanics/interfaces/IMechanicMintManager.sol";

/**
 * @title ERC721 Editions
 * @author highlight.xyz
 * @notice Multiple Editions Per Collection
 * @dev Using Decentralized File Storage
 */
contract ERC721EditionsDFS is
    IEditionCollection,
    IERC721EditionsDFS,
    IERC721EditionMint,
    ERC721Base,
    ERC721Upgradeable,
    MarketplaceFiltererAbridged
{
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
     * @notice Throw when edition doesn't exist
     */
    error EditionDoesNotExist();

    /**
     * @notice Throw when token doesn't exist
     */
    error TokenDoesNotExist();

    /**
     * @notice Throw when attempting to mint, while mint is frozen
     */
    error MintFrozen();

    /**
     * @notice Throw when tokens on edition are sold out
     */
    error SoldOut();

    /**
     * @notice Throw when edition size is invalid
     */
    error InvalidSize();

    /**
     * @notice Throw when edition metadata update is blocked
     */
    error MetadataUpdateBlocked();

    /**
     * @notice Contract metadata
     */
    string public contractURI;

    /**
     * @notice Keeps track of next token ID
     */
    uint256 public nextTokenId;

    /**
     * @notice Tracks current supply of each edition, edition indexed
     */
    uint256[] public editionCurrentSupply;

    /**
     * @notice Tracks size of each edition, edition indexed
     */
    uint256[] public editionMaxSupply;

    /**
     * @notice Tracks start token id each edition, edition indexed
     */
    uint256[] public editionStartId;

    /**
     * @notice Track metadata per edition
     */
    mapping(uint256 => string) private _editionURI;

    /**
     * @notice Emitted when edition is created
     * @param editionId Edition ID
     * @param size Edition size
     * @param editionTokenManager Token manager for edition
     */
    event EditionCreated(uint256 indexed editionId, uint256 indexed size, address indexed editionTokenManager);

    /**
     * @notice Initialize the contract
     * @param data Contract initialization data
     * @ param creator Creator/owner of contract
     * @ param _contractURI Contract metadata
     * @ param _name Name of token edition
     * @ param _symbol Symbol of the token edition
     * @ param trustedForwarder Trusted minimal forwarder
     * @ param initialMinters Initial minters to register
     * @ param useMarketplaceFiltererRegistry Denotes whether to use marketplace filterer registry
     * @ param _observability Observability contract address
     */
    function initialize(bytes calldata data) external initializer {
        (
            address creator,
            string memory _contractURI,
            string memory _name,
            string memory _symbol,
            address trustedForwarder,
            address[] memory initialMinters,
            bool useMarketplaceFiltererRegistry,
            address _observability
        ) = abi.decode(data, (address, string, string, string, address, address[], bool, address));

        IRoyaltyManager.Royalty memory _defaultRoyalty = IRoyaltyManager.Royalty(address(0), 0);
        _initialize(
            creator,
            _defaultRoyalty,
            address(0),
            _contractURI,
            _name,
            _symbol,
            trustedForwarder,
            initialMinters,
            useMarketplaceFiltererRegistry,
            _observability
        );
    }

    /**
     * @notice Create edition
     * @param _editionUri Edition uri (metadata)
     * @param _editionSize Size of the Edition
     * @param _editionTokenManager Edition's token manager
     * @param editionRoyalty Edition royalty object for contract (optional)
     * @param mintVectorData Direct mint vector data
     * @notice Used to create a new Edition within the Collection
     */
    function createEdition(
        string memory _editionUri,
        uint256 _editionSize,
        address _editionTokenManager,
        IRoyaltyManager.Royalty memory editionRoyalty,
        bytes calldata mintVectorData
    ) external onlyOwner nonReentrant returns (uint256) {
        uint256 editionId = _createEdition(_editionUri, _editionSize, _editionTokenManager);
        if (editionRoyalty.recipientAddress != address(0)) {
            _royalties[editionId] = editionRoyalty;
        }

        if (mintVectorData.length > 0) {
            (
                address mintManager,
                address paymentRecipient,
                uint48 startTimestamp,
                uint48 endTimestamp,
                uint192 pricePerToken,
                uint48 tokenLimitPerTx,
                uint48 maxTotalClaimableViaVector,
                uint48 maxUserClaimableViaVector,
                address currency
            ) = abi.decode(
                    mintVectorData,
                    (address, address, uint48, uint48, uint192, uint48, uint48, uint48, address)
                );

            IAbridgedMintVector(mintManager).createAbridgedVector(
                IAbridgedMintVector.AbridgedVectorData(
                    uint160(address(this)),
                    startTimestamp,
                    endTimestamp,
                    uint160(paymentRecipient),
                    maxTotalClaimableViaVector,
                    0,
                    uint160(currency),
                    tokenLimitPerTx,
                    maxUserClaimableViaVector,
                    pricePerToken,
                    uint48(editionId), // cast down
                    true,
                    false,
                    0
                )
            );
        }

        return editionId;
    }

    /**
     * @notice Used to create a new Edition within the Collection
     * @param _editionUri Edition uri (metadata)
     * @param _editionSize Size of the Edition
     * @param _editionTokenManager Edition's token manager
     * @param editionRoyalty Edition royalty object for contract (optional)
     * @param mechanicVectorData Mechanic mint vector data
     * @ param mechanicVectorId Global mechanic vector ID
     * @ param mechanic Mechanic address
     * @ param mintManager Mint manager address
     * @ param vectorData Vector data
     */
    function createEditionWithMechanicVector(
        string memory _editionUri,
        uint256 _editionSize,
        address _editionTokenManager,
        IRoyaltyManager.Royalty memory editionRoyalty,
        bytes calldata mechanicVectorData
    ) external onlyOwner nonReentrant returns (uint256) {
        uint256 editionId = _createEdition(_editionUri, _editionSize, _editionTokenManager);
        if (editionRoyalty.recipientAddress != address(0)) {
            _royalties[editionId] = editionRoyalty;
        }

        if (mechanicVectorData.length > 0) {
            (uint96 seed, address mechanic, address mintManager, bytes memory vectorData) = abi.decode(
                mechanicVectorData,
                (uint96, address, address, bytes)
            );

            IMechanicMintManager(mintManager).registerMechanicVector(
                IMechanicData.MechanicVectorMetadata(address(this), uint96(editionId), mechanic, true, false, false),
                seed,
                vectorData
            );
        }

        return editionId;
    }

    /**
     * @notice Create edition with auction
     * @param _editionUri Edition uri (metadata)
     * @param auctionData Auction data
     * @param _editionTokenManager Edition's token manager
     * @param editionRoyalty Edition royalty object for contract (optional)
     * @notice Used to create a new 1/1 Edition Collection within the contract, and an auction for it
     */
    function createEditionWithAuction(
        string memory _editionUri,
        bytes memory auctionData,
        address _editionTokenManager,
        IRoyaltyManager.Royalty memory editionRoyalty
    ) external onlyOwner nonReentrant returns (uint256) {
        uint256 editionId = _createEdition(_editionUri, 1, _editionTokenManager);
        if (editionRoyalty.recipientAddress != address(0)) {
            _royalties[editionId] = editionRoyalty;
        }

        (
            address auctionManagerAddress,
            bytes32 auctionId,
            address auctionCurrency,
            address payable auctionPaymentRecipient,
            uint256 auctionEndTime
        ) = abi.decode(auctionData, (address, bytes32, address, address, uint256));

        IAuctionManager.EnglishAuction memory auction = IAuctionManager.EnglishAuction(
            address(this),
            auctionCurrency,
            msg.sender,
            auctionPaymentRecipient,
            auctionEndTime,
            0,
            true,
            IAuctionManager.AuctionState.LIVE_ON_CHAIN
        );

        IAuctionManager(auctionManagerAddress).createAuctionForNewEdition(auctionId, auction, editionId);

        return editionId;
    }

    /**
     * @notice See {IERC721EditionMint-mintOneToRecipient}
     */
    function mintOneToRecipient(
        uint256 editionId,
        address recipient
    ) external onlyMinter nonReentrant returns (uint256) {
        if (_mintFrozen == 1) {
            _revert(MintFrozen.selector);
        }
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }

        return _mintEditionsToOne(editionId, recipient, 1);
    }

    /**
     * @notice See {IERC721EditionMint-mintAmountToRecipient}
     */
    function mintAmountToRecipient(
        uint256 editionId,
        address recipient,
        uint256 amount
    ) external onlyMinter nonReentrant returns (uint256) {
        if (_mintFrozen == 1) {
            _revert(MintFrozen.selector);
        }
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }

        return _mintEditionsToOne(editionId, recipient, amount);
    }

    /**
     * @notice See {IERC721EditionMint-mintOneToRecipients}
     */
    function mintOneToRecipients(
        uint256 editionId,
        address[] memory recipients
    ) external onlyMinter nonReentrant returns (uint256) {
        if (_mintFrozen == 1) {
            _revert(MintFrozen.selector);
        }
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }

        return _mintEditions(editionId, recipients, 1);
    }

    /**
     * @notice See {IERC721EditionMint-mintAmountToRecipients}
     */
    function mintAmountToRecipients(
        uint256 editionId,
        address[] memory recipients,
        uint256 amount
    ) external onlyMinter nonReentrant returns (uint256) {
        if (_mintFrozen == 1) {
            _revert(MintFrozen.selector);
        }
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }

        return _mintEditions(editionId, recipients, amount);
    }

    /**
     * @notice Set contract name
     * @param newName New name
     * @param newSymbol New symbol
     * @param newContractUri New contractURI
     */
    function setContractMetadata(
        string calldata newName,
        string calldata newSymbol,
        string calldata newContractUri
    ) external onlyOwner {
        _setContractMetadata(newName, newSymbol);
        contractURI = newContractUri;

        observability.emitContractMetadataSet(newName, newSymbol, newContractUri);
    }

    /**
     * @notice Set an Edition's uri
     * @param editionId Edition to set uri for
     * @param _uri Uri to set on editions
     */
    function setEditionURI(uint256 editionId, string calldata _uri) external {
        address _manager = tokenManager(editionId);
        address msgSender = _msgSender();

        if (_manager == address(0)) {
            address tempOwner = owner();
            if (msgSender != tempOwner) {
                _revert(Unauthorized.selector);
            }
        } else {
            if (
                !ITokenManagerEditions(_manager).canUpdateEditionsMetadata(
                    address(this),
                    msgSender,
                    editionId,
                    bytes(_uri),
                    ITokenManagerEditions.FieldUpdated.other
                )
            ) {
                _revert(MetadataUpdateBlocked.selector);
            }
        }

        _editionURI[editionId] = _uri;

        uint256[] memory _ids = new uint256[](1);
        _ids[0] = editionId;
        string[] memory _uris = new string[](1);
        _uris[0] = _uri;
        observability.emitTokenURIsSet(_ids, _uris);
    }

    /**
     * @notice See {IEditionCollection-getEditionDetails}
     */
    function getEditionDetails(uint256 editionId) external view returns (EditionDetails memory) {
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }
        return _getEditionDetails(editionId);
    }

    /**
     * @notice See {IEditionCollection-getEditionsDetailsAndUri}
     */
    function getEditionsDetailsAndUri(
        uint256[] calldata editionIds
    ) external view returns (EditionDetails[] memory, string[] memory) {
        uint256 editionIdsLength = editionIds.length;
        EditionDetails[] memory editionsDetails = new EditionDetails[](editionIdsLength);
        string[] memory uris = new string[](editionIdsLength);

        for (uint256 i = 0; i < editionIdsLength; i++) {
            uris[i] = editionURI(editionIds[i]);
            editionsDetails[i] = _getEditionDetails(editionIds[i]);
        }

        return (editionsDetails, uris);
    }

    /**
     * @notice See {IEditionCollection-getEditionStartIds}
     */
    function getEditionStartIds() external view returns (uint256[] memory) {
        return editionStartId;
    }

    /**
     * @notice Total supply of NFTs on the Editions
     * @dev Won't handle burned (temporary)
     */
    function totalSupply() external view returns (uint256) {
        uint256 supply = 0;
        for (uint256 i = 0; i < editionCurrentSupply.length; i++) {
            supply += editionCurrentSupply[i];
        }
        return supply;
    }

    /**
     * @notice See {IERC721-setApprovalForAll}.
     *         Overrides default behaviour to check MarketplaceFilterer allowed operators.
     */
    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    /**
     * @notice See {IERC721-approve}.
     *         Overrides default behaviour to check MarketplaceFilterer allowed operators.
     */
    function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    /**
     * @notice See {IERC721-burn}. Overrides default behaviour to check associated tokenManager.
     */
    function burn(uint256 tokenId) public nonReentrant {
        uint256 editionId = getEditionId(tokenId);
        address _manager = tokenManager(editionId);
        address msgSender = _msgSender();

        if (_manager != address(0) && IERC165Upgradeable(_manager).supportsInterface(type(IPostBurn).interfaceId)) {
            IPostBurn(_manager).postBurn(msgSender, ownerOf(tokenId), editionId);
        } else {
            // default to restricting burn to owner or operator if a valid TM isn't present
            if (!_isApprovedOrOwner(msgSender, tokenId)) {
                _revert(Unauthorized.selector);
            }
        }

        _burn(tokenId);

        observability.emitTransfer(msgSender, address(0), tokenId);
    }

    /**
     * @notice Conforms to ERC-2981.
     * @param _tokenId Token id
     * @param _salePrice Sale price of token
     */
    function royaltyInfo(
        uint256 _tokenId,
        uint256 _salePrice
    ) public view virtual override returns (address receiver, uint256 royaltyAmount) {
        return ERC721Base.royaltyInfo(_getEditionId(_tokenId), _salePrice);
    }

    /**
     * @notice See {IEditionCollection-getEditionId}
     */
    function getEditionId(uint256 tokenId) public view returns (uint256) {
        if (!_exists(tokenId)) {
            _revert(TokenDoesNotExist.selector);
        }
        return _getEditionId(tokenId);
    }

    /**
     * @notice Used to get token manager of token id
     * @param tokenId ID of the token
     */
    function tokenManagerByTokenId(uint256 tokenId) public view returns (address) {
        return tokenManager(getEditionId(tokenId));
    }

    /**
     * @notice Get URI for given edition id
     * @param editionId edition id to get uri for
     * @return base64-encoded json metadata object
     */
    function editionURI(uint256 editionId) public view returns (string memory) {
        if (!_editionExists(editionId)) {
            _revert(EditionDoesNotExist.selector);
        }
        return _editionURI[editionId];
    }

    /**
     * @notice Get URI for given token id
     * @param tokenId token id to get uri for
     * @return base64-encoded json metadata object
     */
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (!_exists(tokenId)) {
            _revert(TokenDoesNotExist.selector);
        }
        uint256 editionId = getEditionId(tokenId);
        return _editionURI[editionId];
    }

    /**
     * @notice See {IERC721Upgradeable-supportsInterface}.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(IERC165Upgradeable, ERC721Upgradeable) returns (bool) {
        return ERC721Upgradeable.supportsInterface(interfaceId);
    }

    /**
     * @notice Private function to mint without any access checks. Called by the public edition minting functions.
     * @param editionId Edition being minted on
     * @param recipients Recipients of newly minted tokens
     * @param _amount Amount minted to each recipient
     */
    function _mintEditions(uint256 editionId, address[] memory recipients, uint256 _amount) internal returns (uint256) {
        uint256 recipientsLength = recipients.length;

        uint256 maxSupply = editionMaxSupply[editionId];
        uint256 currentSupply = editionCurrentSupply[editionId];
        uint256 startId = editionStartId[editionId];
        uint256 endAt = currentSupply + (recipientsLength * _amount);

        if (endAt > maxSupply) {
            _revert(SoldOut.selector);
        }

        for (uint256 i = 0; i < recipientsLength; i++) {
            for (uint256 j = 0; j < _amount; j++) {
                _mint(recipients[i], startId + currentSupply);
                currentSupply += 1;
            }
        }

        editionCurrentSupply[editionId] = currentSupply;

        return endAt;
    }

    /**
     * @notice Private function to mint without any access checks. Called by the public edition minting functions.
     * @param editionId Edition being minted on
     * @param recipient Recipient of newly minted token
     * @param _amount Amount minted to recipient
     */
    function _mintEditionsToOne(uint256 editionId, address recipient, uint256 _amount) internal returns (uint256) {
        uint256 maxSupply = editionMaxSupply[editionId];
        uint256 currentSupply = editionCurrentSupply[editionId];
        uint256 startId = editionStartId[editionId];
        uint256 endAt = currentSupply + _amount;

        if (endAt > maxSupply) {
            _revert(SoldOut.selector);
        }

        for (uint256 j = 0; j < _amount; j++) {
            _mint(recipient, startId + currentSupply);
            currentSupply += 1;
        }

        editionCurrentSupply[editionId] = endAt;

        return endAt;
    }

    /**
     * @notice Hook called after transfers
     * @param from Account token is being transferred from
     * @param to Account token is being transferred to
     * @param tokenId ID of token being transferred
     */
    function _afterTokenTransfers(address from, address to, uint256 tokenId) internal override {
        address msgSender = _msgSender();
        if (from != msgSender) {
            _checkFilterOperator(msgSender);
        }

        address _manager = tokenManagerByTokenId(tokenId);
        if (_manager != address(0) && IERC165Upgradeable(_manager).supportsInterface(type(IPostTransfer).interfaceId)) {
            IPostTransfer(_manager).postTransferFrom(msgSender, from, to, tokenId);
        }

        observability.emitTransfer(from, to, tokenId);
    }

    /**
     * @notice Get ID of a token's edition
     */
    function _getEditionId(uint256 tokenId) internal view returns (uint256) {
        uint256 editionId = 0;
        uint256[] memory tempEditionStartId = editionStartId; // cache
        uint256 tempEditionStartIdLength = tempEditionStartId.length; // cache
        for (uint256 i = 0; i < tempEditionStartIdLength; i += 1) {
            if (tokenId >= tempEditionStartId[i]) {
                editionId = i;
            }
        }
        return editionId;
    }

    /**
     * @notice Returns whether `editionId` exists.
     * @param editionId Id of edition being checked
     */
    function _editionExists(uint256 editionId) internal view returns (bool) {
        return editionId < editionCurrentSupply.length;
    }

    /**
     * @notice Used for meta-transactions
     */
    function _msgSender() internal view override(ERC721Base, ContextUpgradeable) returns (address sender) {
        return ERC2771ContextUpgradeable._msgSender();
    }

    /**
     * @notice Used for meta-transactions
     */
    function _msgData() internal view override(ERC721Base, ContextUpgradeable) returns (bytes calldata) {
        return ERC2771ContextUpgradeable._msgData();
    }

    /**
     * @dev For more efficient reverts.
     */
    function _revert(
        bytes4 errorSelector
    ) internal pure override(ERC721Upgradeable, ERC721Base, MarketplaceFiltererAbridged) {
        ERC721Upgradeable._revert(errorSelector);
    }

    /**
     * @notice Initialize the contract
     * @param creator Creator/owner of contract
     * @param defaultRoyalty Default royalty object for contract (optional)
     * @param _defaultTokenManager Default token manager for contract (optional)
     * @param _contractURI Contract metadata
     * @param _name Name of token edition
     * @param _symbol Symbol of the token edition
     * @param trustedForwarder Trusted minimal forwarder
     * @param initialMinters Initial minters to register
     * @param useMarketplaceFiltererRegistry Denotes whether to use marketplace filterer registry
     * @param _observability Observability contract address
     */
    function _initialize(
        address creator,
        IRoyaltyManager.Royalty memory defaultRoyalty,
        address _defaultTokenManager,
        string memory _contractURI,
        string memory _name,
        string memory _symbol,
        address trustedForwarder,
        address[] memory initialMinters,
        bool useMarketplaceFiltererRegistry,
        address _observability
    ) private {
        __ERC721Base_initialize(creator, defaultRoyalty, _defaultTokenManager);
        __ERC721_init(_name, _symbol);
        __ERC2771ContextUpgradeable__init__(trustedForwarder);
        // deprecate but keep input for backwards-compatibility:
        // __MarketplaceFilterer__init__(useMarketplaceFiltererRegistry);
        uint256 initialMintersLength = initialMinters.length;
        for (uint256 i = 0; i < initialMintersLength; i++) {
            _minters.add(initialMinters[i]);
        }
        nextTokenId = 1;
        contractURI = _contractURI;
        IObservability(_observability).emitMultipleEditionsDeployed(address(this));
        observability = IObservability(_observability);
    }

    /**
     * @notice Create edition
     * @param _editionUri Edition uri (metadata)
     * @param _editionSize Size of the Edition
     * @param _editionTokenManager Edition's token manager
     * @notice Used to create a new Edition within the Collection
     */
    function _createEdition(
        string memory _editionUri,
        uint256 _editionSize,
        address _editionTokenManager
    ) private returns (uint256) {
        if (_editionSize == 0) {
            _revert(InvalidSize.selector);
        }

        uint256 editionId = editionStartId.length;

        editionStartId.push(nextTokenId);
        editionMaxSupply.push(_editionSize);
        editionCurrentSupply.push(0);

        nextTokenId += _editionSize;

        _editionURI[editionId] = _editionUri;

        if (_editionTokenManager != address(0)) {
            if (!_isValidTokenManager(_editionTokenManager)) {
                _revert(InvalidManager.selector);
            }
            _managers[editionId] = _editionTokenManager;
        }

        emit EditionCreated(editionId, _editionSize, _editionTokenManager);

        return editionId;
    }

    /**
     * @notice Get edition details
     * @param editionId Id of edition to get details for
     */
    function _getEditionDetails(uint256 editionId) private view returns (EditionDetails memory) {
        return
            EditionDetails("", editionMaxSupply[editionId], editionCurrentSupply[editionId], editionStartId[editionId]);
    }
}

File 2 of 40 : OwnableUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

File 3 of 40 : Initializable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

File 4 of 40 : ReentrancyGuardUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.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 ReentrancyGuardUpgradeable is Initializable {
    // 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;

    uint256 private _status;

    function __ReentrancyGuard_init() internal onlyInitializing {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal onlyInitializing {
        _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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

File 5 of 40 : AddressUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 6 of 40 : ContextUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

File 7 of 40 : MathUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library MathUpgradeable {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

File 8 of 40 : SignedMathUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMathUpgradeable {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

File 9 of 40 : StringsUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = MathUpgradeable.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, MathUpgradeable.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

File 10 of 40 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 11 of 40 : EnumerableSet.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

File 12 of 40 : IAuctionManager.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.10;

import { IMinimalForwarder } from "./IMinimalForwarder.sol";

/**
 * @title Interface for AuctionManager
 * @notice Defines behaviour encapsulated in AuctionManager
 * @author highlight.xyz
 */
interface IAuctionManager {
    /**
     * @notice The state an auction is in
     * @param NON_EXISTENT Default state of auction pre-creation
     * @param LIVE_ON_CHAIN State of auction after creation but before the auction ends or is cancelled
     * @param CANCELLED_ON_CHAIN State of auction after auction is cancelled
     * @param FULFILLED State of auction after winning bid has been dispersed and NFT has left escrow
     */
    enum AuctionState {
        NON_EXISTENT,
        LIVE_ON_CHAIN,
        CANCELLED_ON_CHAIN,
        FULFILLED
    }

    /**
     * @notice The data structure containing all fields on an English Auction that need to be on-chain
     * @param collection The collection hosting the auctioned NFT
     * @param currency The currency bids must be made in
     * @param owner The auction owner
     * @param paymentRecipient The recipient account of the winning bid
     * @param endTime When the auction will tentatively end. Is 0 if first bid hasn't been made
     * @param tokenId The ID of the NFT being auctioned
     * @param mintWhenReserveMet If true, new NFT will be minted when reserve crossing bid is made
     * @param state Auction state
     */
    struct EnglishAuction {
        address collection;
        address currency;
        address owner;
        address payable paymentRecipient;
        uint256 endTime;
        uint256 tokenId; // if nft already exists
        bool mintWhenReserveMet;
        AuctionState state;
    }

    /**
     * @notice Used for information about auctions on editions
     * @param used True if the auction is for an auction on an edition
     * @param editionId ID of the edition used for this auction
     */
    struct EditionAuction {
        bool used;
        uint256 editionId;
    }

    /**
     * @notice Data required for a bidder to make a bid. Claims are signed, hashed and validated, acting as bid keys
     * @param auctionId ID of auction
     * @param bidPrice Price that bidder is bidding
     * @param reservePrice Price that bidder must bid greater than. Only relevant for the first bid on an auction
     * @param maxClaimsPerAccount Max bids that an account can make on an auction. Unlimited if 0
     * @param claimExpiryTimestamp Time when claim expires
     * @param buffer Minimum time that must be left in an auction after a bid is made
     * @param minimumIncrementPerBidPctBPS Minimum % that a bid must be higher than the previous highest bid by,
     *                                     in basis points
     * @param claimer Account that can use the claim
     */
    struct Claim {
        bytes32 auctionId;
        uint256 bidPrice;
        uint256 reservePrice;
        uint256 maxClaimsPerAccount;
        uint256 claimExpiryTimestamp;
        uint256 buffer;
        uint256 minimumIncrementPerBidPctBPS;
        address payable claimer;
    }

    /**
     * @notice Structure hosting highest bidder info
     * @param bidder Bidder with current highest bid
     * @param preferredNFTRecipient The account that the current highest bidder wants the NFT to go to if they win.
     *                              Useful for non-transferable NFTs being auctioned.
     * @param amount Amount of current highest bid
     */
    struct HighestBidderData {
        address payable bidder;
        address preferredNFTRecipient;
        uint256 amount;
    }

    /**
     * @notice Emitted when an english auction is created
     * @param auctionId ID of auction
     * @param owner Auction owner
     * @param collection Collection that NFT being auctioned is on
     * @param tokenId ID of NFT being auctioned
     * @param currency The currency bids must be made in
     * @param paymentRecipient The recipient account of the winning bid
     * @param endTime Auction end time
     */
    event EnglishAuctionCreated(
        bytes32 indexed auctionId,
        address indexed owner,
        address indexed collection,
        uint256 tokenId,
        address currency,
        address paymentRecipient,
        uint256 endTime
    );

    /**
     * @notice Emitted when a valid bid is made on an auction
     * @param auctionId ID of auction
     * @param bidder Bidder with new highest bid
     * @param firstBid True if this is the first bid, ie. first bid greater than reserve price
     * @param collection Collection that NFT being auctioned is on
     * @param tokenId ID of NFT being auctioned
     * @param value Value of bid
     * @param timeLengthened True if this bid extended the end time of the auction (by being bid >= endTime - buffer)
     * @param preferredNFTRecipient The account that the current highest bidder wants the NFT to go to if they win.
     *                              Useful for non-transferable NFTs being auctioned.
     * @param endTime The current end time of the auction
     */
    event Bid(
        bytes32 indexed auctionId,
        address indexed bidder,
        bool indexed firstBid,
        address collection,
        uint256 tokenId,
        uint256 value,
        bool timeLengthened,
        address preferredNFTRecipient,
        uint256 endTime
    );

    /**
     * @notice Emitted when an auction's end time is extended
     * @param auctionId ID of auction
     * @param tokenId ID of NFT being auctioned
     * @param collection Collection that NFT being auctioned is on
     * @param buffer Minimum time that must be left in an auction after a bid is made
     * @param newEndTime New end time of auction
     */
    event TimeLengthened(
        bytes32 indexed auctionId,
        uint256 indexed tokenId,
        address indexed collection,
        uint256 buffer,
        uint256 newEndTime
    );

    /**
     * @notice Emitted when an auction is won, and its terms are fulfilled
     * @param auctionId ID of auction
     * @param tokenId ID of NFT being auctioned
     * @param collection Collection that NFT being auctioned is on
     * @param owner Auction owner
     * @param winner Winning bidder
     * @param paymentRecipient The recipient account of the winning bid
     * @param nftRecipient The account receiving the auctioned NFT
     * @param currency The currency bids were made in
     * @param amount Winning bid value
     * @param paymentRecipientPctBPS The percentage of the winning bid going to the paymentRecipient, in basis points
     */
    event AuctionWon(
        bytes32 indexed auctionId,
        uint256 indexed tokenId,
        address indexed collection,
        address owner,
        address winner,
        address paymentRecipient,
        address nftRecipient,
        address currency,
        uint256 amount,
        uint256 paymentRecipientPctBPS
    );

    /**
     * @notice Emitted when an auction is cancelled on-chain (before any valid bids have been made).
     * @param auctionId ID of auction
     * @param owner Auction owner
     * @param collection Collection that NFT was being auctioned on
     * @param tokenId ID of NFT that was being auctioned
     */
    event AuctionCanceledOnChain(
        bytes32 indexed auctionId,
        address indexed owner,
        address indexed collection,
        uint256 tokenId
    );

    /**
     * @notice Emitted when the payment recipient of an auction is updated
     * @param auctionId ID of auction
     * @param owner Auction owner
     * @param newPaymentRecipient New payment recipient of auction
     */
    event PaymentRecipientUpdated(
        bytes32 indexed auctionId,
        address indexed owner,
        address indexed newPaymentRecipient
    );

    /**
     * @notice Emitted when the preferred NFT recipient of an auctionbid  is updated
     * @param auctionId ID of auction
     * @param owner Auction owner
     * @param newPreferredNFTRecipient New preferred nft recipient of auction
     */
    event PreferredNFTRecipientUpdated(
        bytes32 indexed auctionId,
        address indexed owner,
        address indexed newPreferredNFTRecipient
    );

    /**
     * @notice Emitted when the end time of an auction is updated
     * @param auctionId ID of auction
     * @param owner Auction owner
     * @param newEndTime New end time
     */
    event EndTimeUpdated(bytes32 indexed auctionId, address indexed owner, uint256 indexed newEndTime);

    /**
     * @notice Emitted when the platform is updated
     * @param newPlatform New platform
     */
    event PlatformUpdated(address newPlatform);

    /**
     * @notice Create an auction that mints the NFT being auctioned into escrow (mints the next NFT on the collection)
     * @param auctionId ID of auction
     * @param auction The auction details
     */
    function createAuctionForNewToken(bytes32 auctionId, EnglishAuction memory auction) external;

    /**
     * @notice Create an auction that mints an edition being auctioned into escrow (mints the next NFT on the edition)
     * @param auctionId ID of auction
     * @param auction The auction details
     */
    function createAuctionForNewEdition(
        bytes32 auctionId,
        IAuctionManager.EnglishAuction memory auction,
        uint256 editionId
    ) external;

    /**
     * @notice Create an auction for an existing NFT
     * @param auctionId ID of auction
     * @param auction The auction details
     */
    function createAuctionForExistingToken(bytes32 auctionId, EnglishAuction memory auction) external;

    /**
     * @notice Create an auction for an existing NFT, with atomic transfer approval meta-tx packets
     * @param auctionId ID of auction
     * @param auction The auction details
     * @param req The request containing the call to transfer the auctioned NFT into escrow
     * @param requestSignature The signed request
     */
    function createAuctionForExistingTokenWithMetaTxPacket(
        bytes32 auctionId,
        IAuctionManager.EnglishAuction memory auction,
        IMinimalForwarder.ForwardRequest calldata req,
        bytes calldata requestSignature
    ) external;

    /**
     * @notice Update the payment recipient for an auction
     * @param auctionId ID of auction being updated
     * @param newPaymentRecipient New payment recipient on the auction
     */
    function updatePaymentRecipient(bytes32 auctionId, address payable newPaymentRecipient) external;

    /**
     * @notice Update the preferred nft recipient of a bid
     * @param auctionId ID of auction being updated
     * @param newPreferredNFTRecipient New nft recipient on the auction bid
     */
    function updatePreferredNFTRecipient(bytes32 auctionId, address newPreferredNFTRecipient) external;

    /**
     * @notice Makes a bid on an auction
     * @param claim Claim needed to make the bid
     * @param claimSignature Claim signature to be unwrapped and validated
     * @param preferredNftRecipient Bidder's preferred recipient of NFT if they win auction
     */
    function bid(
        IAuctionManager.Claim calldata claim,
        bytes calldata claimSignature,
        address preferredNftRecipient
    ) external payable;

    /**
     * @notice Fulfill auction and disperse winning bid / auctioned NFT.
     * @dev Anyone can call this function
     * @param auctionId ID of auction to fulfill
     */
    function fulfillAuction(bytes32 auctionId) external;

    /**
     * @notice "Cancels" an auction on-chain, if a valid bid hasn't been made yet. Transfers NFT back to auction owner
     * @param auctionId ID of auction being "cancelled"
     */
    function cancelAuctionOnChain(bytes32 auctionId) external;

    /**
     * @notice Updates the platform account receiving a portion of winning bids
     * @param newPlatform New account to receive portion
     */
    function updatePlatform(address payable newPlatform) external;

    /**
     * @notice Updates the platform cut
     * @param newCutBPS New account to receive portion
     */
    function updatePlatformCut(uint256 newCutBPS) external;

    /**
     * @notice Update an auction's end time before first valid bid is made on auction
     * @param auctionId Auction ID
     * @param newEndTime New end time
     */
    function updateEndTime(bytes32 auctionId, uint256 newEndTime) external;

    /**
     * @notice Verifies the validity of a claim, simulating call to bid()
     * @param claim Claim needed to make the bid
     * @param claimSignature Claim signature to be unwrapped and validated
     * @param expectedMsgSender Expected msg.sender when bid() is called, that is being simulated
     */
    function verifyClaim(
        Claim calldata claim,
        bytes calldata claimSignature,
        address expectedMsgSender
    ) external view returns (bool);

    /**
     * @notice Get all data about an auction except for number of bids made per user
     * @param auctionId ID of auction
     */
    function getFullAuctionData(
        bytes32 auctionId
    ) external view returns (EnglishAuction memory, HighestBidderData memory, EditionAuction memory);

    /**
     * @notice Get all data about a set of auctions except for number of bids made per user
     * @param auctionIds IDs of auctions
     */
    function getFullAuctionsData(
        bytes32[] calldata auctionIds
    ) external view returns (EnglishAuction[] memory, HighestBidderData[] memory, EditionAuction[] memory);
}

File 13 of 40 : IMinimalForwarder.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.10;

/**
 * @title Minimal forwarder interface
 * @author highlight.xyz
 */
interface IMinimalForwarder {
    struct ForwardRequest {
        address from;
        address to;
        uint256 value;
        uint256 gas;
        uint256 nonce;
        bytes data;
    }

    function execute(
        ForwardRequest calldata req,
        bytes calldata signature
    ) external payable returns (bool, bytes memory);

    function getNonce(address from) external view returns (uint256);

    function verify(ForwardRequest calldata req, bytes calldata signature) external view returns (bool);
}

File 14 of 40 : ERC721Base.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "../royaltyManager/interfaces/IRoyaltyManager.sol";
import "../tokenManager/interfaces/ITokenManager.sol";
import "../utils/Ownable.sol";
import "../utils/ERC2981/IERC2981Upgradeable.sol";
import "../utils/ERC165/ERC165CheckerUpgradeable.sol";
import "../metatx/ERC2771ContextUpgradeable.sol";
import "../observability/IObservability.sol";

import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";

/**
 * @title Base ERC721
 * @author highlight.xyz
 * @notice Core piece of Highlight NFT contracts (v2)
 */
abstract contract ERC721Base is
    OwnableUpgradeable,
    IERC2981Upgradeable,
    ERC2771ContextUpgradeable,
    ReentrancyGuardUpgradeable
{
    using EnumerableSet for EnumerableSet.AddressSet;
    using ERC165CheckerUpgradeable for address;

    /**
     * @notice Throw when token or royalty manager is invalid
     */
    error InvalidManager();

    /**
     * @notice Throw when token or royalty manager does not exist
     */
    error ManagerDoesNotExist();

    /**
     * @notice Throw when sender is unauthorized to perform action
     */
    error Unauthorized();

    /**
     * @notice Throw when sender is not a minter
     */
    error NotMinter();

    /**
     * @notice Throw when token manager or royalty manager swap is blocked
     */
    error ManagerSwapBlocked();

    /**
     * @notice Throw when token manager or royalty manager remove is blocked
     */
    error ManagerRemoveBlocked();

    /**
     * @notice Throw when setting default or granular royalty is blocked
     */
    error RoyaltySetBlocked();

    /**
     * @notice Throw when royalty BPS is invalid
     */
    error RoyaltyBPSInvalid();

    /**
     * @notice Throw when minter registration is invalid
     */
    error MinterRegistrationInvalid();

    /**
     * @notice Set of minters allowed to mint on contract
     */
    EnumerableSet.AddressSet internal _minters;

    /**
     * @notice Global token/edition manager default
     */
    address public defaultManager;

    /**
     * @notice Token/edition managers per token grouping.
     *      Edition ID if implemented by Editions contract, and token ID if implemented by General contract.
     */
    mapping(uint256 => address) internal _managers;

    /**
     * @notice Default royalty for entire contract
     */
    IRoyaltyManager.Royalty internal _defaultRoyalty;

    /**
     * @notice Royalty per token grouping.
     *      Edition ID if implemented by Editions contract, and token ID if implemented by General contract.
     */
    mapping(uint256 => IRoyaltyManager.Royalty) internal _royalties;

    /**
     * @notice Royalty manager - optional contract that defines the conditions around setting royalties
     */
    address public royaltyManager;

    /**
     * @notice Freezes minting on smart contract forever
     */
    uint8 internal _mintFrozen;

    /**
     * @notice Observability contract
     */
    IObservability public observability;

    /**
     * @notice Emitted when minter is registered or unregistered
     * @param minter Minter that was changed
     * @param registered True if the minter was registered, false if unregistered
     */
    event MinterRegistrationChanged(address indexed minter, bool indexed registered);

    /**
     * @notice Emitted when token managers are set for token/edition ids
     * @param _ids Edition / token ids
     * @param _tokenManagers Token managers to set for tokens / editions
     */
    event GranularTokenManagersSet(uint256[] _ids, address[] _tokenManagers);

    /**
     * @notice Emitted when token managers are removed for token/edition ids
     * @param _ids Edition / token ids to remove token managers for
     */
    event GranularTokenManagersRemoved(uint256[] _ids);

    /**
     * @notice Emitted when default token manager changed
     * @param newDefaultTokenManager New default token manager. Zero address if old one was removed
     */
    event DefaultTokenManagerChanged(address indexed newDefaultTokenManager);

    /**
     * @notice Emitted when default royalty is set
     * @param recipientAddress Royalty recipient
     * @param royaltyPercentageBPS Percentage of sale (in basis points) owed to royalty recipient
     */
    event DefaultRoyaltySet(address indexed recipientAddress, uint16 indexed royaltyPercentageBPS);

    /**
     * @notice Emitted when royalties are set for edition / token ids
     * @param ids Token / edition ids
     * @param _newRoyalties New royalties for each token / edition
     */
    event GranularRoyaltiesSet(uint256[] ids, IRoyaltyManager.Royalty[] _newRoyalties);

    /**
     * @notice Emitted when royalty manager is updated
     * @param newRoyaltyManager New royalty manager. Zero address if old one was removed
     */
    event RoyaltyManagerChanged(address indexed newRoyaltyManager);

    /**
     * @notice Emitted when mints are frozen permanently
     */
    event MintsFrozen();

    /**
     * @notice Restricts calls to minters
     */
    modifier onlyMinter() {
        if (!_minters.contains(_msgSender())) {
            _revert(NotMinter.selector);
        }
        _;
    }

    /**
     * @notice Restricts calls if input royalty bps is over 10000
     */
    modifier royaltyValid(uint16 _royaltyBPS) {
        if (!_royaltyBPSValid(_royaltyBPS)) {
            _revert(RoyaltyBPSInvalid.selector);
        }
        _;
    }

    /**
     * @notice Registers a minter
     * @param minter New minter
     */
    function registerMinter(address minter) external onlyOwner {
        if (!_minters.add(minter)) {
            _revert(MinterRegistrationInvalid.selector);
        }

        emit MinterRegistrationChanged(minter, true);
        observability.emitMinterRegistrationChanged(minter, true);
    }

    /**
     * @notice Unregisters a minter
     * @param minter Minter to unregister
     */
    function unregisterMinter(address minter) external onlyOwner {
        if (!_minters.remove(minter)) {
            _revert(MinterRegistrationInvalid.selector);
        }

        emit MinterRegistrationChanged(minter, false);
        observability.emitMinterRegistrationChanged(minter, false);
    }

    /**
     * @notice Sets granular token managers if current token manager(s) allow it
     * @param _ids Edition / token ids
     * @param _tokenManagers Token managers to set for tokens / editions
     */
    function setGranularTokenManagers(
        uint256[] calldata _ids,
        address[] calldata _tokenManagers
    ) external nonReentrant {
        address msgSender = _msgSender();
        address tempOwner = owner();

        uint256 idsLength = _ids.length;
        for (uint256 i = 0; i < idsLength; i++) {
            if (!_isValidTokenManager(_tokenManagers[i])) {
                _revert(InvalidManager.selector);
            }
            address currentTokenManager = tokenManager(_ids[i]);
            if (currentTokenManager == address(0)) {
                if (msgSender != tempOwner) {
                    _revert(Unauthorized.selector);
                }
            } else {
                if (!ITokenManager(currentTokenManager).canSwap(msgSender, _ids[i], _managers[i])) {
                    _revert(ManagerSwapBlocked.selector);
                }
            }

            _managers[_ids[i]] = _tokenManagers[i];
        }

        emit GranularTokenManagersSet(_ids, _tokenManagers);
        observability.emitGranularTokenManagersSet(_ids, _tokenManagers);
    }

    /**
     * @notice Remove granular token managers
     * @param _ids Edition / token ids to remove token managers for
     */
    function removeGranularTokenManagers(uint256[] calldata _ids) external nonReentrant {
        address msgSender = _msgSender();

        uint256 idsLength = _ids.length;
        for (uint256 i = 0; i < idsLength; i++) {
            address currentTokenManager = _managers[_ids[i]];
            if (currentTokenManager == address(0)) {
                _revert(ManagerDoesNotExist.selector);
            }
            if (!ITokenManager(currentTokenManager).canRemoveItself(msgSender, _ids[i])) {
                _revert(ManagerRemoveBlocked.selector);
            }

            _managers[_ids[i]] = address(0);
        }

        emit GranularTokenManagersRemoved(_ids);
        observability.emitGranularTokenManagersRemoved(_ids);
    }

    /**
     * @notice Set default token manager if current token manager allows it
     * @param _defaultTokenManager New default token manager
     */
    function setDefaultTokenManager(address _defaultTokenManager) external nonReentrant {
        if (!_isValidTokenManager(_defaultTokenManager)) {
            _revert(InvalidManager.selector);
        }
        address msgSender = _msgSender();

        address currentTokenManager = defaultManager;
        if (currentTokenManager == address(0)) {
            if (msgSender != owner()) {
                _revert(Unauthorized.selector);
            }
        } else {
            if (!ITokenManager(currentTokenManager).canSwap(msgSender, 0, _defaultTokenManager)) {
                _revert(ManagerSwapBlocked.selector);
            }
        }

        defaultManager = _defaultTokenManager;

        emit DefaultTokenManagerChanged(_defaultTokenManager);
        observability.emitDefaultTokenManagerChanged(_defaultTokenManager);
    }

    /**
     * @notice Removes default token manager if current token manager allows it
     */
    function removeDefaultTokenManager() external nonReentrant {
        address msgSender = _msgSender();

        address currentTokenManager = defaultManager;
        if (currentTokenManager == address(0)) {
            _revert(ManagerDoesNotExist.selector);
        }
        if (!ITokenManager(currentTokenManager).canRemoveItself(msgSender, 0)) {
            _revert(ManagerRemoveBlocked.selector);
        }

        defaultManager = address(0);

        emit DefaultTokenManagerChanged(address(0));
        observability.emitDefaultTokenManagerChanged(address(0));
    }

    /**
     * @notice Sets default royalty if royalty manager allows it
     * @param _royalty New default royalty
     */
    function setDefaultRoyalty(
        IRoyaltyManager.Royalty calldata _royalty
    ) external nonReentrant royaltyValid(_royalty.royaltyPercentageBPS) {
        address msgSender = _msgSender();

        address _royaltyManager = royaltyManager;
        if (_royaltyManager == address(0)) {
            if (msgSender != owner()) {
                _revert(Unauthorized.selector);
            }
        } else {
            if (!IRoyaltyManager(_royaltyManager).canSetDefaultRoyalty(_royalty, msgSender)) {
                _revert(RoyaltySetBlocked.selector);
            }
        }

        _defaultRoyalty = _royalty;

        emit DefaultRoyaltySet(_royalty.recipientAddress, _royalty.royaltyPercentageBPS);
        observability.emitDefaultRoyaltySet(_royalty.recipientAddress, _royalty.royaltyPercentageBPS);
    }

    /**
     * @notice Sets granular royalties (per token-grouping) if royalty manager allows it
     * @param ids Token / edition ids
     * @param _newRoyalties New royalties for each token / edition
     */
    function setGranularRoyalties(
        uint256[] calldata ids,
        IRoyaltyManager.Royalty[] calldata _newRoyalties
    ) external nonReentrant {
        address msgSender = _msgSender();
        address tempOwner = owner();

        address _royaltyManager = royaltyManager;
        uint256 idsLength = ids.length;
        if (_royaltyManager == address(0)) {
            if (msgSender != tempOwner) {
                _revert(Unauthorized.selector);
            }

            for (uint256 i = 0; i < idsLength; i++) {
                if (!_royaltyBPSValid(_newRoyalties[i].royaltyPercentageBPS)) {
                    _revert(RoyaltyBPSInvalid.selector);
                }
                _royalties[ids[i]] = _newRoyalties[i];
            }
        } else {
            for (uint256 i = 0; i < idsLength; i++) {
                if (!_royaltyBPSValid(_newRoyalties[i].royaltyPercentageBPS)) {
                    _revert(RoyaltyBPSInvalid.selector);
                }
                if (!IRoyaltyManager(_royaltyManager).canSetGranularRoyalty(ids[i], _newRoyalties[i], msgSender)) {
                    _revert(RoyaltySetBlocked.selector);
                }
                _royalties[ids[i]] = _newRoyalties[i];
            }
        }

        emit GranularRoyaltiesSet(ids, _newRoyalties);
        observability.emitGranularRoyaltiesSet(ids, _newRoyalties);
    }

    /**
     * @notice Sets royalty manager if current one allows it
     * @param _royaltyManager New royalty manager
     */
    function setRoyaltyManager(address _royaltyManager) external nonReentrant {
        if (!_isValidRoyaltyManager(_royaltyManager)) {
            _revert(InvalidManager.selector);
        }
        address msgSender = _msgSender();

        address currentRoyaltyManager = royaltyManager;
        if (currentRoyaltyManager == address(0)) {
            if (msgSender != owner()) {
                _revert(Unauthorized.selector);
            }
        } else {
            if (!IRoyaltyManager(currentRoyaltyManager).canSwap(_royaltyManager, msgSender)) {
                _revert(ManagerSwapBlocked.selector);
            }
        }

        royaltyManager = _royaltyManager;

        emit RoyaltyManagerChanged(_royaltyManager);
        observability.emitRoyaltyManagerChanged(_royaltyManager);
    }

    /**
     * @notice Removes royalty manager if current one allows it
     */
    function removeRoyaltyManager() external nonReentrant {
        address msgSender = _msgSender();

        address currentRoyaltyManager = royaltyManager;
        if (currentRoyaltyManager == address(0)) {
            _revert(ManagerDoesNotExist.selector);
        }
        if (!IRoyaltyManager(currentRoyaltyManager).canRemoveItself(msgSender)) {
            _revert(ManagerRemoveBlocked.selector);
        }

        royaltyManager = address(0);

        emit RoyaltyManagerChanged(address(0));
        observability.emitRoyaltyManagerChanged(address(0));
    }

    /**
     * @notice Freeze mints on contract forever
     */
    function freezeMints() external onlyOwner nonReentrant {
        _mintFrozen = 1;

        emit MintsFrozen();
        observability.emitMintsFrozen();
    }

    /**
     * @notice Return allowed minters on contract
     */
    function minters() external view returns (address[] memory) {
        return _minters.values();
    }

    /**
     * @notice Conforms to ERC-2981. Editions should overwrite to return royalty for entire edition
     * @param _tokenGroupingId Token id if on general, and edition id if on editions
     * @param _salePrice Sale price of token
     */
    function royaltyInfo(
        uint256 _tokenGroupingId,
        uint256 _salePrice
    ) public view virtual override returns (address receiver, uint256 royaltyAmount) {
        IRoyaltyManager.Royalty memory royalty = _royalties[_tokenGroupingId];
        if (royalty.recipientAddress == address(0)) {
            royalty = _defaultRoyalty;
        }

        receiver = royalty.recipientAddress;
        royaltyAmount = (_salePrice * uint256(royalty.royaltyPercentageBPS)) / 10000;
    }

    /**
     * @notice Returns the token manager for the id passed in.
     * @param id Token ID or Edition ID for Editions implementing contracts
     */
    function tokenManager(uint256 id) public view returns (address manager) {
        manager = defaultManager;
        address granularManager = _managers[id];

        if (granularManager != address(0)) {
            manager = granularManager;
        }
    }

    /**
     * @notice Initializes the contract, setting the creator as the initial owner.
     * @param _creator Contract creator
     * @param defaultRoyalty Default royalty for the contract
     * @param _defaultTokenManager Default token manager for the contract
     */
    function __ERC721Base_initialize(
        address _creator,
        IRoyaltyManager.Royalty memory defaultRoyalty,
        address _defaultTokenManager
    ) internal onlyInitializing royaltyValid(defaultRoyalty.royaltyPercentageBPS) {
        __Ownable_init();
        __ReentrancyGuard_init();
        _transferOwnership(_creator);

        if (defaultRoyalty.recipientAddress != address(0)) {
            _defaultRoyalty = defaultRoyalty;
        }

        if (_defaultTokenManager != address(0)) {
            defaultManager = _defaultTokenManager;
        }
    }

    /**
     * @notice Returns true if address is a valid tokenManager
     * @param _tokenManager Token manager being checked
     */
    function _isValidTokenManager(address _tokenManager) internal view returns (bool) {
        return _tokenManager.supportsInterface(type(ITokenManager).interfaceId);
    }

    /**
     * @notice Returns true if address is a valid royaltyManager
     * @param _royaltyManager Royalty manager being checked
     */
    function _isValidRoyaltyManager(address _royaltyManager) internal view returns (bool) {
        return _royaltyManager.supportsInterface(type(IRoyaltyManager).interfaceId);
    }

    /**
     * @notice Used for meta-transactions
     */
    function _msgSender()
        internal
        view
        virtual
        override(ContextUpgradeable, ERC2771ContextUpgradeable)
        returns (address sender)
    {
        return ERC2771ContextUpgradeable._msgSender();
    }

    /**
     * @dev For more efficient reverts.
     */
    function _revert(bytes4 errorSelector) internal pure virtual {
        assembly {
            mstore(0x00, errorSelector)
            revert(0x00, 0x04)
        }
    }

    /**
     * @notice Used for meta-transactions
     */
    function _msgData()
        internal
        view
        virtual
        override(ContextUpgradeable, ERC2771ContextUpgradeable)
        returns (bytes calldata)
    {
        return ERC2771ContextUpgradeable._msgData();
    }

    /**
     * @notice Returns true if royalty bps passed in is valid (<= 10000)
     * @param _royaltyBPS Royalty basis points
     */
    function _royaltyBPSValid(uint16 _royaltyBPS) private pure returns (bool) {
        return _royaltyBPS <= 10000;
    }
}

File 15 of 40 : IEditionCollection.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @notice Interfaces with the details of editions on collections
 * @author highlight.xyz
 */
interface IEditionCollection {
    /**
     * @notice Edition details
     * @param name Edition name
     * @param size Edition size
     * @param supply Total number of tokens minted on edition
     * @param initialTokenId Token id of first token minted in edition
     */
    struct EditionDetails {
        string name;
        uint256 size;
        uint256 supply;
        uint256 initialTokenId;
    }

    /**
     * @notice Get the edition a token belongs to
     * @param tokenId The token id of the token
     */
    function getEditionId(uint256 tokenId) external view returns (uint256);

    /**
     * @notice Get an edition's details
     * @param editionId Edition id
     */
    function getEditionDetails(uint256 editionId) external view returns (EditionDetails memory);

    /**
     * @notice Get the details and uris of a number of editions
     * @param editionIds List of editions to get info for
     */
    function getEditionsDetailsAndUri(
        uint256[] calldata editionIds
    ) external view returns (EditionDetails[] memory, string[] memory uris);
}

File 16 of 40 : IERC721EditionMint.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @notice Mint interface on editions contracts
 * @author highlight.xyz
 */
interface IERC721EditionMint {
    /**
     * @notice Mints one NFT to one recipient
     * @param editionId Edition to mint the NFT on
     * @param recipient Recipient of minted NFT
     */
    function mintOneToRecipient(uint256 editionId, address recipient) external returns (uint256);

    /**
     * @notice Mints an amount of NFTs to one recipient
     * @param editionId Edition to mint the NFTs on
     * @param recipient Recipient of minted NFTs
     * @param amount Amount of NFTs minted
     */
    function mintAmountToRecipient(uint256 editionId, address recipient, uint256 amount) external returns (uint256);

    /**
     * @notice Mints one NFT each to a number of recipients
     * @param editionId Edition to mint the NFTs on
     * @param recipients Recipients of minted NFTs
     */
    function mintOneToRecipients(uint256 editionId, address[] memory recipients) external returns (uint256);

    /**
     * @notice Mints an amount of NFTs each to a number of recipients
     * @param editionId Edition to mint the NFTs on
     * @param recipients Recipients of minted NFTs
     * @param amount Amount of NFTs minted per recipient
     */
    function mintAmountToRecipients(
        uint256 editionId,
        address[] memory recipients,
        uint256 amount
    ) external returns (uint256);
}

File 17 of 40 : IERC721EditionsDFS.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "../../royaltyManager/interfaces/IRoyaltyManager.sol";

/**
 * @notice Core creation interface
 * @author highlight.xyz
 */
interface IERC721EditionsDFS {
    /**
     * @notice Create an edition
     * @param _editionUri Edition uri (metadata)
     * @param _editionSize Edition size
     * @param _editionTokenManager Token manager for edition
     * @param editionRoyalty Edition's royalty
     */
    function createEdition(
        string memory _editionUri,
        uint256 _editionSize,
        address _editionTokenManager,
        IRoyaltyManager.Royalty memory editionRoyalty,
        bytes calldata mintVectorData
    ) external returns (uint256);

    /**
     * @notice Get the first token minted for each edition passed in
     */
    function getEditionStartIds() external view returns (uint256[] memory);
}

File 18 of 40 : IOperatorFilterRegistry.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    function register(address registrant) external;

    function registerAndSubscribe(address registrant, address subscription) external;

    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    function unregister(address addr) 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);
}

File 19 of 40 : MarketplaceFiltererAbridged.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

import { IOperatorFilterRegistry } from "./interfaces/IOperatorFilterRegistry.sol";

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

/**
 * @title  MarketplaceFiltererAbridged
 * @notice Abstract contract whose constructor automatically registers and subscribes to default
           subscription from OpenSea, if a valid registry is passed in. 
           Modified from `OperatorFilterer` contract by ishan@ highlight.xyz.
 * @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 MarketplaceFiltererAbridged is OwnableUpgradeable {
    error NotAContract();

    error OperatorNotAllowed();

    /**
     * @notice MarketplaceFilterer Registry (CORI)
     */
    address private constant _MARKETPLACE_FILTERER_REGISTRY = address(0x000000000000AAeB6D7670E522A718067333cd4E);

    /**
     * @notice Default subscription to register collection with on CORI Marketplace filterer registry
     */
    address private constant _DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    /**
     * @notice CORI Marketplace filterer registry. Set to address(0) when not used to avoid extra inter-contract calls.
     */
    address public operatorFiltererRegistry;

    function __MarketplaceFilterer__init__(bool useFilterer) internal onlyInitializing {
        // 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 (useFilterer) {
            _setRegistryAndSubscription(_MARKETPLACE_FILTERER_REGISTRY, _DEFAULT_SUBSCRIPTION);
        }
    }

    /**
     * @notice Update the address that the contract will make MarketplaceFilterer checks against.
     *         Also register this contract with that registry.
     */
    function setRegistryAndSubscription(address newRegistry, address subscription) external onlyOwner {
        _setRegistryAndSubscription(newRegistry, subscription);
    }

    modifier onlyAllowedOperatorApproval(address operator) {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (operatorFiltererRegistry != address(0)) {
            if (!IOperatorFilterRegistry(operatorFiltererRegistry).isOperatorAllowed(address(this), operator)) {
                _revert(OperatorNotAllowed.selector);
            }
        }
    }

    function _setRegistryAndSubscription(address newRegistry, address subscription) private {
        operatorFiltererRegistry = newRegistry;
        if (newRegistry != address(0)) {
            if (newRegistry.code.length == 0) {
                _revert(NotAContract.selector);
            }
            IOperatorFilterRegistry(newRegistry).registerAndSubscribe(address(this), subscription);
        }
    }

    /**
     * @dev For more efficient reverts.
     */
    function _revert(bytes4 errorSelector) internal pure virtual {
        assembly {
            mstore(0x00, errorSelector)
            revert(0x00, 0x04)
        }
    }
}

File 20 of 40 : IEditionsMetadataRenderer.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @notice Used to interface with EditionsMetadataRenderer
 * @author highlight.xyz
 */
interface IEditionsMetadataRenderer {
    /**
     * @notice Token edition info
     * @param name Edition name
     * @param description Edition description
     * @param imageUrl Edition image url
     * @param animationUrl Edition animation url
     * @param externalUrl Edition external url
     * @param attributes Edition attributes
     */
    struct TokenEditionInfo {
        string name;
        string description;
        string imageUrl;
        string animationUrl;
        string externalUrl;
        string attributes;
    }

    /**
     * @notice Updates name on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param name New name of edition
     */
    function updateName(address editionsAddress, uint256 editionId, string calldata name) external;

    /**
     * @notice Updates description on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param description New description of edition
     */
    function updateDescription(address editionsAddress, uint256 editionId, string calldata description) external;

    /**
     * @notice Updates imageUrl on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param imageUrl New imageUrl of edition
     */
    function updateImageUrl(address editionsAddress, uint256 editionId, string calldata imageUrl) external;

    /**
     * @notice Updates animationUrl on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param animationUrl New animationUrl of edition
     */
    function updateAnimationUrl(address editionsAddress, uint256 editionId, string calldata animationUrl) external;

    /**
     * @notice Updates externalUrl on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param externalUrl New externalUrl of edition
     */
    function updateExternalUrl(address editionsAddress, uint256 editionId, string calldata externalUrl) external;

    /**
     * @notice Updates attributes on edition. Managed by token manager if existent
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param attributes New attributes of edition
     */
    function updateAttributes(address editionsAddress, uint256 editionId, string calldata attributes) external;

    /**
     * @notice Updates any set of metadata fields
     * @param editionsAddress Address of collection that edition is on
     * @param editionId ID of edition to update
     * @param tokenEditionInfo New metadata fields
     * @param updateIds Encoded what metadata fields to update
     */
    function updateMetadata(
        address editionsAddress,
        uint256 editionId,
        TokenEditionInfo calldata tokenEditionInfo,
        uint256[] calldata updateIds
    ) external;

    /**
     * @notice Get an edition's uri. HAS to be called by collection
     * @param editionId Edition's id to get uri for
     */
    function editionURI(uint256 editionId) external view returns (string memory);

    /**
     * @notice Get an edition's info.
     * @param editionsAddress Address of collection that edition is on
     * @param editionsId Edition's id to get info for
     */
    function editionInfo(address editionsAddress, uint256 editionsId) external view returns (TokenEditionInfo memory);
}

File 21 of 40 : IMetadataRenderer.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @notice Used to interface with core of EditionsMetadataRenderer
 * @author Zora, [email protected]
 */
interface IMetadataRenderer {
    /**
     * @notice Store metadata for an edition
     * @param data Metadata
     */
    function initializeMetadata(bytes memory data) external;

    /**
     * @notice Get uri for token
     * @param tokenId ID of token to get uri for
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

File 22 of 40 : ERC2771ContextUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (metatx/ERC2771Context.sol)

pragma solidity 0.8.10;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @dev Context variant with ERC2771 support.
 *      Openzeppelin contract slightly modified by ishan@ highlight.xyz to be upgradeable.
 */
abstract contract ERC2771ContextUpgradeable is Initializable {
    address private _trustedForwarder;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;

    function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
        return forwarder == _trustedForwarder;
    }

    function __ERC2771ContextUpgradeable__init__(address trustedForwarder) internal onlyInitializing {
        _trustedForwarder = trustedForwarder;
    }

    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`.
            /* solhint-disable no-inline-assembly */
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
            /* solhint-enable no-inline-assembly */
        } 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;
        }
    }
}

File 23 of 40 : IAbridgedMintVector.sol
// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.10;

/**
 * @title MintManager interface for onchain abridged mint vectors
 * @author highlight.xyz
 */
interface IAbridgedMintVector {
    /**
     * @notice On-chain mint vector (stored data)
     * @param contractAddress NFT smart contract address
     * @param startTimestamp When minting opens on vector
     * @param endTimestamp When minting ends on vector
     * @param paymentRecipient Payment recipient
     * @param maxTotalClaimableViaVector Max number of tokens that can be minted via vector
     * @param totalClaimedViaVector Total number of tokens minted via vector
     * @param currency Currency used for payment. Native gas token, if zero address
     * @param tokenLimitPerTx Max number of tokens that can be minted in one transaction
     * @param maxUserClaimableViaVector Max number of tokens that can be minted by user via vector
     * @param pricePerToken Price that has to be paid per minted token
     * @param editionId Edition ID, if vector is for edition based collection
     * @param editionBasedCollection If vector is for an edition based collection
     * @param requireDirectEOA Require minters to directly be EOAs
     * @param allowlistRoot Root of merkle tree with allowlist
     */
    struct AbridgedVectorData {
        uint160 contractAddress;
        uint48 startTimestamp;
        uint48 endTimestamp;
        uint160 paymentRecipient;
        uint48 maxTotalClaimableViaVector;
        uint48 totalClaimedViaVector;
        uint160 currency;
        uint48 tokenLimitPerTx;
        uint48 maxUserClaimableViaVector;
        uint192 pricePerToken;
        uint48 editionId;
        bool editionBasedCollection;
        bool requireDirectEOA;
        bytes32 allowlistRoot;
    }

    /**
     * @notice On-chain mint vector (public) - See {AbridgedVectorData}
     */
    struct AbridgedVector {
        address contractAddress;
        uint48 startTimestamp;
        uint48 endTimestamp;
        address paymentRecipient;
        uint48 maxTotalClaimableViaVector;
        uint48 totalClaimedViaVector;
        address currency;
        uint48 tokenLimitPerTx;
        uint48 maxUserClaimableViaVector;
        uint192 pricePerToken;
        uint48 editionId;
        bool editionBasedCollection;
        bool requireDirectEOA;
        bytes32 allowlistRoot;
    }

    /**
     * @notice Config defining what fields to update
     * @param updateStartTimestamp If 1, update startTimestamp
     * @param updateEndTimestamp If 1, update endTimestamp
     * @param updatePaymentRecipient If 1, update paymentRecipient
     * @param updateMaxTotalClaimableViaVector If 1, update maxTotalClaimableViaVector
     * @param updateTokenLimitPerTx If 1, update tokenLimitPerTx
     * @param updateMaxUserClaimableViaVector If 1, update maxUserClaimableViaVector
     * @param updatePricePerToken If 1, update pricePerToken
     * @param updateCurrency If 1, update currency
     * @param updateRequireDirectEOA If 1, update requireDirectEOA
     * @param updateMetadata If 1, update MintVector metadata
     */
    struct UpdateAbridgedVectorConfig {
        uint16 updateStartTimestamp;
        uint16 updateEndTimestamp;
        uint16 updatePaymentRecipient;
        uint16 updateMaxTotalClaimableViaVector;
        uint16 updateTokenLimitPerTx;
        uint16 updateMaxUserClaimableViaVector;
        uint8 updatePricePerToken;
        uint8 updateCurrency;
        uint8 updateRequireDirectEOA;
        uint8 updateMetadata;
    }

    /**
     * @notice Creates on-chain vector
     * @param _vector Vector to create
     */
    function createAbridgedVector(AbridgedVectorData memory _vector) external;

    /**
     * @notice Updates on-chain vector
     * @param vectorId ID of vector to update
     * @param _newVector New vector details
     * @param updateConfig Number encoding what fields to update
     * @param pause Pause / unpause vector
     * @param flexibleData Flexible data in vector metadata
     */
    function updateAbridgedVector(
        uint256 vectorId,
        AbridgedVector calldata _newVector,
        UpdateAbridgedVectorConfig calldata updateConfig,
        bool pause,
        uint128 flexibleData
    ) external;

    /**
     * @notice Pauses or unpauses an on-chain mint vector
     * @param vectorId ID of abridged vector to pause
     * @param pause True to pause, False to unpause
     * @param flexibleData Flexible data that can be interpreted differently
     */
    function setAbridgedVectorMetadata(uint256 vectorId, bool pause, uint128 flexibleData) external;

    /**
     * @notice Get on-chain abridged vector
     * @param vectorId ID of abridged vector to get
     */
    function getAbridgedVector(uint256 vectorId) external view returns (AbridgedVector memory);

    /**
     * @notice Get on-chain abridged vector metadata
     * @param vectorId ID of abridged vector to get
     */
    function getAbridgedVectorMetadata(uint256 vectorId) external view returns (bool, uint128);
}

File 24 of 40 : IMechanicData.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @notice Defines a mechanic's metadata on the MintManager
 */
interface IMechanicData {
    /**
     * @notice A mechanic's metadata
     * @param contractAddress Collection contract address
     * @param editionId Edition ID if the collection is edition based
     * @param mechanic Address of mint mechanic contract
     * @param isEditionBased True if collection is edition based
     * @param isChoose True if collection uses a collector's choice mint paradigm
     * @param paused True if mechanic vector is paused
     */
    struct MechanicVectorMetadata {
        address contractAddress;
        uint96 editionId;
        address mechanic;
        bool isEditionBased;
        bool isChoose;
        bool paused;
    }
}

File 25 of 40 : IMechanicMintManager.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "./IMechanicData.sol";

/**
 * @notice Capabilities on MintManager pertaining to mechanics
 */
interface IMechanicMintManager is IMechanicData {
    /**
     * @notice Register a new mechanic vector
     * @param _mechanicVectorMetadata Mechanic vector metadata
     * @param seed Used to seed uniqueness into mechanic vector ID generation
     * @param vectorData Vector data to store on mechanic (optional)
     */
    function registerMechanicVector(
        MechanicVectorMetadata calldata _mechanicVectorMetadata,
        uint96 seed,
        bytes calldata vectorData
    ) external;

    /**
     * @notice Pause or unpause a mechanic vector
     * @param mechanicVectorId Global mechanic ID
     * @param pause If true, pause the mechanic mint vector. If false, unpause
     */
    function setPauseOnMechanicMintVector(bytes32 mechanicVectorId, bool pause) external;

    /**
     * @notice Mint a number of tokens sequentially via a mechanic vector
     * @param mechanicVectorId Global mechanic ID
     * @param recipient Mint recipient
     * @param numToMint Number of tokens to mint
     * @param data Custom data to be processed by mechanic
     */
    function mechanicMintNum(
        bytes32 mechanicVectorId,
        address recipient,
        uint32 numToMint,
        bytes calldata data
    ) external payable;

    /**
     * @notice Mint a specific set of token ids via a mechanic vector
     * @param mechanicVectorId Global mechanic ID
     * @param recipient Mint recipient
     * @param tokenIds IDs of tokens to mint
     * @param data Custom data to be processed by mechanic
     */
    function mechanicMintChoose(
        bytes32 mechanicVectorId,
        address recipient,
        uint256[] calldata tokenIds,
        bytes calldata data
    ) external payable;
}

File 26 of 40 : IObservability.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "../royaltyManager/interfaces/IRoyaltyManager.sol";

/**
 * @title IObservability
 * @author highlight.xyz
 * @notice Interface to interact with the Highlight observability singleton
 * @dev Singleton to coalesce select Highlight protocol events
 */
interface IObservability {
    /**************************
      ERC721Base / ERC721MinimizedBase events
     **************************/

    /**
     * @notice Emitted when minter is registered or unregistered
     * @param contractAddress Initial contract that emitted event
     * @param minter Minter that was changed
     * @param registered True if the minter was registered, false if unregistered
     */
    event MinterRegistrationChanged(address indexed contractAddress, address indexed minter, bool indexed registered);

    /**
     * @notice Emitted when token managers are set for token/edition ids
     * @param contractAddress Initial contract that emitted event
     * @param _ids Edition / token ids
     * @param _tokenManagers Token managers to set for tokens / editions
     */
    event GranularTokenManagersSet(address indexed contractAddress, uint256[] _ids, address[] _tokenManagers);

    /**
     * @notice Emitted when token managers are removed for token/edition ids
     * @param contractAddress Initial contract that emitted event
     * @param _ids Edition / token ids to remove token managers for
     */
    event GranularTokenManagersRemoved(address indexed contractAddress, uint256[] _ids);

    /**
     * @notice Emitted when default token manager changed
     * @param contractAddress Initial contract that emitted event
     * @param newDefaultTokenManager New default token manager. Zero address if old one was removed
     */
    event DefaultTokenManagerChanged(address indexed contractAddress, address indexed newDefaultTokenManager);

    /**
     * @notice Emitted when default royalty is set
     * @param contractAddress Initial contract that emitted event
     * @param recipientAddress Royalty recipient
     * @param royaltyPercentageBPS Percentage of sale (in basis points) owed to royalty recipient
     */
    event DefaultRoyaltySet(
        address indexed contractAddress,
        address indexed recipientAddress,
        uint16 indexed royaltyPercentageBPS
    );

    /**
     * @notice Emitted when royalties are set for edition / token ids
     * @param contractAddress Initial contract that emitted event
     * @param ids Token / edition ids
     * @param _newRoyalties New royalties for each token / edition
     */
    event GranularRoyaltiesSet(address indexed contractAddress, uint256[] ids, IRoyaltyManager.Royalty[] _newRoyalties);

    /**
     * @notice Emitted when royalty manager is updated
     * @param contractAddress Initial contract that emitted event
     * @param newRoyaltyManager New royalty manager. Zero address if old one was removed
     */
    event RoyaltyManagerChanged(address indexed contractAddress, address indexed newRoyaltyManager);

    /**
     * @notice Emitted when mints are frozen permanently
     * @param contractAddress Initial contract that emitted event
     */
    event MintsFrozen(address indexed contractAddress);

    /**
     * @notice Emitted when contract metadata is set
     * @param contractAddress Initial contract that emitted event
     * @param name New name
     * @param symbol New symbol
     * @param contractURI New contract uri
     */
    event ContractMetadataSet(address indexed contractAddress, string name, string symbol, string contractURI);

    /**************************
      ERC721General events
     **************************/

    /**
     * @notice Emitted when hashed metadata config is set
     * @param contractAddress Initial contract that emitted event
     * @param hashedURIData Hashed uri data
     * @param hashedRotationData Hashed rotation key
     * @param _supply Supply of tokens to mint w/ reveal
     */
    event HashedMetadataConfigSet(
        address indexed contractAddress,
        bytes hashedURIData,
        bytes hashedRotationData,
        uint256 indexed _supply
    );

    /**
     * @notice Emitted when metadata is revealed
     * @param contractAddress Initial contract that emitted event
     * @param key Key used to decode hashed data
     * @param newRotationKey Actual rotation key to be used
     */
    event Revealed(address indexed contractAddress, bytes key, uint256 newRotationKey);

    /**************************
      ERC721GeneralBase events
     **************************/

    /**
     * @notice Emitted when uris are set for tokens
     * @param contractAddress Initial contract that emitted event
     * @param ids IDs of tokens to set uris for
     * @param uris Uris to set on tokens
     */
    event TokenURIsSet(address indexed contractAddress, uint256[] ids, string[] uris);

    /**
     * @notice Emitted when limit supply is set
     * @param contractAddress Initial contract that emitted event
     * @param newLimitSupply Limit supply to set
     */
    event LimitSupplySet(address indexed contractAddress, uint256 indexed newLimitSupply);

    /**************************
      ERC721StorageUri events
     **************************/

    /**
     * @notice Emits when a series collection has its base uri set
     * @param contractAddress Contract with updated base uri
     * @param newBaseUri New base uri
     */
    event BaseUriSet(address indexed contractAddress, string newBaseUri);

    /**************************
      ERC721Editions / ERC721SingleEdition events
     **************************/

    // Not adding EditionCreated, EditionMintedToOneRecipient, EditionMintedToRecipients
    // EditionCreated - handled by MetadataInitialized
    // EditionMintedToOneRecipient / EditionMintedToRecipients - handled via mint module events

    /**************************
      Deployment events
     **************************/

    /**
     * @notice Emitted when Generative Series contract is deployed
     * @param deployer Contract deployer
     * @param contractAddress Address of contract that was deployed
     */
    event GenerativeSeriesDeployed(address indexed deployer, address indexed contractAddress);

    /**
     * @notice Emitted when Series contract is deployed
     * @param deployer Contract deployer
     * @param contractAddress Address of contract that was deployed
     */
    event SeriesDeployed(address indexed deployer, address indexed contractAddress);

    /**
     * @notice Emitted when MultipleEditions contract is deployed
     * @param deployer Contract deployer
     * @param contractAddress Address of contract that was deployed
     */
    event MultipleEditionsDeployed(address indexed deployer, address indexed contractAddress);

    /**
     * @notice Emitted when SingleEdition contract is deployed
     * @param deployer Contract deployer
     * @param contractAddress Address of contract that was deployed
     */
    event SingleEditionDeployed(address indexed deployer, address indexed contractAddress);

    /**************************
      ERC721 events
     **************************/

    /**
     * @notice Emitted when `tokenId` token is transferred from `from` to `to` on contractAddress
     * @param contractAddress NFT contract token resides on
     * @param from Token sender
     * @param to Token receiver
     * @param tokenId Token being sent
     */
    event Transfer(address indexed contractAddress, address indexed from, address to, uint256 indexed tokenId);

    /**
     * @notice Emit MinterRegistrationChanged
     */
    function emitMinterRegistrationChanged(address minter, bool registered) external;

    /**
     * @notice Emit GranularTokenManagersSet
     */
    function emitGranularTokenManagersSet(uint256[] calldata _ids, address[] calldata _tokenManagers) external;

    /**
     * @notice Emit GranularTokenManagersRemoved
     */
    function emitGranularTokenManagersRemoved(uint256[] calldata _ids) external;

    /**
     * @notice Emit DefaultTokenManagerChanged
     */
    function emitDefaultTokenManagerChanged(address newDefaultTokenManager) external;

    /**
     * @notice Emit DefaultRoyaltySet
     */
    function emitDefaultRoyaltySet(address recipientAddress, uint16 royaltyPercentageBPS) external;

    /**
     * @notice Emit GranularRoyaltiesSet
     */
    function emitGranularRoyaltiesSet(
        uint256[] calldata ids,
        IRoyaltyManager.Royalty[] calldata _newRoyalties
    ) external;

    /**
     * @notice Emit RoyaltyManagerChanged
     */
    function emitRoyaltyManagerChanged(address newRoyaltyManager) external;

    /**
     * @notice Emit MintsFrozen
     */
    function emitMintsFrozen() external;

    /**
     * @notice Emit ContractMetadataSet
     */
    function emitContractMetadataSet(
        string calldata name,
        string calldata symbol,
        string calldata contractURI
    ) external;

    /**
     * @notice Emit HashedMetadataConfigSet
     */
    function emitHashedMetadataConfigSet(
        bytes calldata hashedURIData,
        bytes calldata hashedRotationData,
        uint256 _supply
    ) external;

    /**
     * @notice Emit Revealed
     */
    function emitRevealed(bytes calldata key, uint256 newRotationKey) external;

    /**
     * @notice Emit TokenURIsSet
     */
    function emitTokenURIsSet(uint256[] calldata ids, string[] calldata uris) external;

    /**
     * @notice Emit LimitSupplySet
     */
    function emitLimitSupplySet(uint256 newLimitSupply) external;

    /**
     * @notice Emit BaseUriSet
     */
    function emitBaseUriSet(string calldata newBaseUri) external;

    /**
     * @notice Emit GenerativeSeriesDeployed
     */
    function emitGenerativeSeriesDeployed(address contractAddress) external;

    /**
     * @notice Emit SeriesDeployed
     */
    function emitSeriesDeployed(address contractAddress) external;

    /**
     * @notice Emit MultipleEditionsDeployed
     */
    function emitMultipleEditionsDeployed(address contractAddress) external;

    /**
     * @notice Emit SingleEditionDeployed
     */
    function emitSingleEditionDeployed(address contractAddress) external;

    /**
     * @notice Emit Transfer
     */
    function emitTransfer(address from, address to, uint256 tokenId) external;
}

File 27 of 40 : IRoyaltyManager.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @title IRoyaltyManager
 * @author highlight.xyz
 * @notice Enables interfacing with custom royalty managers that define conditions on setting royalties for
 *         NFT contracts
 */
interface IRoyaltyManager {
    /**
     * @notice Struct containing values required to adhere to ERC-2981
     * @param recipientAddress Royalty recipient - can be EOA, royalty splitter contract, etc.
     * @param royaltyPercentageBPS Royalty cut, in basis points
     */
    struct Royalty {
        address recipientAddress;
        uint16 royaltyPercentageBPS;
    }

    /**
     * @notice Defines conditions around being able to swap royalty manager for another one
     * @param newRoyaltyManager New royalty manager being swapped in
     * @param sender msg sender
     */
    function canSwap(address newRoyaltyManager, address sender) external view returns (bool);

    /**
     * @notice Defines conditions around being able to remove current royalty manager
     * @param sender msg sender
     */
    function canRemoveItself(address sender) external view returns (bool);

    /**
     * @notice Defines conditions around being able to set granular royalty (per token or per edition)
     * @param id Edition / token ID whose royalty is being set
     * @param royalty Royalty being set
     * @param sender msg sender
     */
    function canSetGranularRoyalty(uint256 id, Royalty calldata royalty, address sender) external view returns (bool);

    /**
     * @notice Defines conditions around being able to set default royalty
     * @param royalty Royalty being set
     * @param sender msg sender
     */
    function canSetDefaultRoyalty(Royalty calldata royalty, address sender) external view returns (bool);
}

File 28 of 40 : IPostBurn.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.8.10;

/**
 * @author highlight.xyz
 * @notice If token managers implement this, transfer actions will call
 *      postBurn on the token manager.
 */
interface IPostBurn {
    /**
     * @notice Hook called by contract after burn, if token manager of burned token implements this
     *      interface.
     * @param operator Operator burning tokens
     * @param sender Msg sender
     * @param id Burned token's id or id of edition of token that is burned
     */
    function postBurn(address operator, address sender, uint256 id) external;
}

File 29 of 40 : IPostTransfer.sol
// SPDX-License-Identifier: MIT

pragma solidity 0.8.10;

/**
 * @author highlight.xyz
 * @notice If token managers implement this, transfer actions will call
 *      postSafeTransferFrom or postTransferFrom on the token manager.
 */
interface IPostTransfer {
    /**
     * @notice Hook called by community after safe transfers, if token manager of transferred token implements this
     *      interface.
     * @param operator Operator transferring tokens
     * @param from Token(s) sender
     * @param to Token(s) recipient
     * @param id Transferred token's id
     * @param data Arbitrary data
     */
    function postSafeTransferFrom(address operator, address from, address to, uint256 id, bytes memory data) external;

    /**
     * @notice Hook called by community after transfers, if token manager of transferred token implements
     *         this interface.
     * @param operator Operator transferring tokens
     * @param from Token(s) sender
     * @param to Token(s) recipient
     * @param id Transferred token's id
     */
    function postTransferFrom(address operator, address from, address to, uint256 id) external;
}

File 30 of 40 : ITokenManager.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

/**
 * @title ITokenManager
 * @author highlight.xyz
 * @notice Enables interfacing with custom token managers
 */
interface ITokenManager {
    /**
     * @notice Returns whether metadata updater is allowed to update
     * @param sender Updater
     * @param id Token/edition who's uri is being updated
     *           If id is 0, implementation should decide behaviour for base uri update
     * @param newData Token's new uri if called by general contract, and any metadata field if called by editions
     * @return If invocation can update metadata
     */
    function canUpdateMetadata(address sender, uint256 id, bytes calldata newData) external returns (bool);

    /**
     * @notice Returns whether token manager can be swapped for another one by invocator
     * @notice Default token manager implementations should ignore id
     * @param sender Swapper
     * @param id Token grouping id (token id or edition id)
     * @param newTokenManager New token manager being swapped to
     * @return If invocation can swap token managers
     */
    function canSwap(address sender, uint256 id, address newTokenManager) external returns (bool);

    /**
     * @notice Returns whether token manager can be removed
     * @notice Default token manager implementations should ignore id
     * @param sender Swapper
     * @param id Token grouping id (token id or edition id)
     * @return If invocation can remove token manager
     */
    function canRemoveItself(address sender, uint256 id) external returns (bool);
}

File 31 of 40 : ITokenManagerEditions.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;

import "./ITokenManager.sol";

/**
 * @title ITokenManager
 * @author highlight.xyz
 * @notice Enables interfacing with custom token managers for editions contracts
 */
interface ITokenManagerEditions is ITokenManager {
    /**
     * @notice The updated field in metadata updates
     */
    enum FieldUpdated {
        name,
        description,
        imageUrl,
        animationUrl,
        externalUrl,
        attributes,
        other
    }

    /**
     * @notice Returns whether metadata updater is allowed to update
     * @param editionsAddress Address of editions contract
     * @param sender Updater
     * @param editionId Token/edition who's uri is being updated
     *           If id is 0, implementation should decide behaviour for base uri update
     * @param newData Token's new uri if called by general contract, and any metadata field if called by editions
     * @param fieldUpdated Which metadata field was updated
     * @return If invocation can update metadata
     */
    function canUpdateEditionsMetadata(
        address editionsAddress,
        address sender,
        uint256 editionId,
        bytes calldata newData,
        FieldUpdated fieldUpdated
    ) external returns (bool);
}

File 32 of 40 : ERC165CheckerUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Checker.sol)

pragma solidity 0.8.10;

import "./IERC165Upgradeable.sol";

/**
 * @dev Library used to query support of an interface declared via {IERC165}.
 *
 * Note that these functions return the actual result of the query: they do not
 * `revert` if an interface is not supported. It is up to the caller to decide
 * what to do in these cases.
 */
/* solhint-disable */
library ERC165CheckerUpgradeable {
    // As per the EIP-165 spec, no interface should ever match 0xffffffff
    bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;

    /**
     * @dev Returns true if `account` supports the {IERC165} interface,
     */
    function supportsERC165(address account) internal view returns (bool) {
        // Any contract that implements ERC165 must explicitly indicate support of
        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
        return
            supportsERC165InterfaceUnchecked(account, type(IERC165Upgradeable).interfaceId) &&
            !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
    }

    /**
     * @dev Returns true if `account` supports the interface defined by
     * `interfaceId`. Support for {IERC165} itself is queried automatically.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
        // query support of both ERC165 as per the spec and support of _interfaceId
        return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
    }

    /**
     * @dev Returns a boolean array where each value corresponds to the
     * interfaces passed in and whether they're supported or not. This allows
     * you to batch check interfaces for a contract where your expectation
     * is that some interfaces may not be supported.
     *
     * See {IERC165-supportsInterface}.
     *
     * _Available since v3.4._
     */
    function getSupportedInterfaces(
        address account,
        bytes4[] memory interfaceIds
    ) internal view returns (bool[] memory) {
        // an array of booleans corresponding to interfaceIds and whether they're supported or not
        bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);

        // query support of ERC165 itself
        if (supportsERC165(account)) {
            // query support of each interface in interfaceIds
            for (uint256 i = 0; i < interfaceIds.length; i++) {
                interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
            }
        }

        return interfaceIdsSupported;
    }

    /**
     * @dev Returns true if `account` supports all the interfaces defined in
     * `interfaceIds`. Support for {IERC165} itself is queried automatically.
     *
     * Batch-querying can lead to gas savings by skipping repeated checks for
     * {IERC165} support.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
        // query support of ERC165 itself
        if (!supportsERC165(account)) {
            return false;
        }

        // query support of each interface in _interfaceIds
        for (uint256 i = 0; i < interfaceIds.length; i++) {
            if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
                return false;
            }
        }

        // all interfaces supported
        return true;
    }

    /**
     * @notice Query if a contract implements an interface, does not check ERC165 support
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return true if the contract at account indicates support of the interface with
     * identifier interfaceId, false otherwise
     * @dev Assumes that account contains a contract that supports ERC165, otherwise
     * the behavior of this method is undefined. This precondition can be checked
     * with {supportsERC165}.
     * Interface identification is specified in ERC-165.
     */
    function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
        // prepare call
        bytes memory encodedParams = abi.encodeWithSelector(IERC165Upgradeable.supportsInterface.selector, interfaceId);

        // perform static call
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly {
            success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0x00)
        }

        return success && returnSize >= 0x20 && returnValue > 0;
    }
}

File 33 of 40 : ERC165Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity 0.8.10;

import "./IERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
/* solhint-disable */
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal onlyInitializing {}

    function __ERC165_init_unchained() internal onlyInitializing {}

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

File 34 of 40 : IERC165Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity 0.8.10;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
/* solhint-disable */
interface IERC165Upgradeable {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

File 35 of 40 : IERC2981Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981Upgradeable.sol)

pragma solidity 0.8.10;

import "../ERC165/IERC165Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

File 36 of 40 : ERC721Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)

pragma solidity 0.8.10;

import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./IERC721MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "../ERC165/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
/* solhint-disable */
contract ERC721Upgradeable is
    Initializable,
    ContextUpgradeable,
    ERC165Upgradeable,
    IERC721Upgradeable,
    IERC721MetadataUpgradeable
{
    using AddressUpgradeable for address;
    using StringsUpgradeable for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC721_init_unchained(name_, symbol_);
    }

    function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
        return
            interfaceId == type(IERC721Upgradeable).interfaceId ||
            interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: Invalid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, "/", tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721Upgradeable.ownerOf(tokenId);
        require(to != owner, "ERC721: already owns");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller unauthorized");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller unauthorized");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: invalid receiver");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721Upgradeable.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, data), "ERC721: invalid receiver");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: zero address");
        require(!_exists(tokenId), "ERC721: token minted");

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721Upgradeable.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: from not owner");
        require(to != address(0), "ERC721: to the zero address");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfers(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Hook that is called after a set of serially-ordered token IDs
     * have been transferred.
     *
     * `startTokenId` - the first token ID to be transferred.
     *
     * Calling conditions:
     *
     * - `from` and `to` are both non-zero, since this is only invoked ont transfers
     */
    function _afterTokenTransfers(address from, address to, uint256 tokenId) internal virtual {}

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Added by Highlight to facilitate updating of name and symbol
     */
    function _setContractMetadata(string calldata newName, string calldata newSymbol) internal {
        _name = newName;
        _symbol = newSymbol;
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (
                bytes4 retval
            ) {
                return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: invalid receiver");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev For more efficient reverts.
     */
    function _revert(bytes4 errorSelector) internal pure virtual {
        assembly {
            mstore(0x00, errorSelector)
            revert(0x00, 0x04)
        }
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[44] private __gap;
}

File 37 of 40 : IERC721MetadataUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity 0.8.10;

import "./IERC721Upgradeable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
/* solhint-disable */
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

File 38 of 40 : IERC721ReceiverUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity 0.8.10;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
/* solhint-disable */
interface IERC721ReceiverUpgradeable {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

File 39 of 40 : IERC721Upgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity 0.8.10;

import "../ERC165/IERC165Upgradeable.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
/* solhint-disable */
interface IERC721Upgradeable is IERC165Upgradeable {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

File 40 of 40 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity 0.8.10;

import "@openzeppelin/contracts/utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
/* solhint-disable */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

Settings
{
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 1
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[],"name":"EditionDoesNotExist","type":"error"},{"inputs":[],"name":"InvalidManager","type":"error"},{"inputs":[],"name":"InvalidSize","type":"error"},{"inputs":[],"name":"ManagerDoesNotExist","type":"error"},{"inputs":[],"name":"ManagerRemoveBlocked","type":"error"},{"inputs":[],"name":"ManagerSwapBlocked","type":"error"},{"inputs":[],"name":"MetadataUpdateBlocked","type":"error"},{"inputs":[],"name":"MintFrozen","type":"error"},{"inputs":[],"name":"MinterRegistrationInvalid","type":"error"},{"inputs":[],"name":"NotAContract","type":"error"},{"inputs":[],"name":"NotMinter","type":"error"},{"inputs":[],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"RoyaltyBPSInvalid","type":"error"},{"inputs":[],"name":"RoyaltySetBlocked","type":"error"},{"inputs":[],"name":"SoldOut","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipientAddress","type":"address"},{"indexed":true,"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"name":"DefaultRoyaltySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newDefaultTokenManager","type":"address"}],"name":"DefaultTokenManagerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"editionId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"size","type":"uint256"},{"indexed":true,"internalType":"address","name":"editionTokenManager","type":"address"}],"name":"EditionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"indexed":false,"internalType":"struct IRoyaltyManager.Royalty[]","name":"_newRoyalties","type":"tuple[]"}],"name":"GranularRoyaltiesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"GranularTokenManagersRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"indexed":false,"internalType":"address[]","name":"_tokenManagers","type":"address[]"}],"name":"GranularTokenManagersSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":true,"internalType":"bool","name":"registered","type":"bool"}],"name":"MinterRegistrationChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"MintsFrozen","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRoyaltyManager","type":"address"}],"name":"RoyaltyManagerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_editionUri","type":"string"},{"internalType":"uint256","name":"_editionSize","type":"uint256"},{"internalType":"address","name":"_editionTokenManager","type":"address"},{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"internalType":"struct IRoyaltyManager.Royalty","name":"editionRoyalty","type":"tuple"},{"internalType":"bytes","name":"mintVectorData","type":"bytes"}],"name":"createEdition","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_editionUri","type":"string"},{"internalType":"bytes","name":"auctionData","type":"bytes"},{"internalType":"address","name":"_editionTokenManager","type":"address"},{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"internalType":"struct IRoyaltyManager.Royalty","name":"editionRoyalty","type":"tuple"}],"name":"createEditionWithAuction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_editionUri","type":"string"},{"internalType":"uint256","name":"_editionSize","type":"uint256"},{"internalType":"address","name":"_editionTokenManager","type":"address"},{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"internalType":"struct IRoyaltyManager.Royalty","name":"editionRoyalty","type":"tuple"},{"internalType":"bytes","name":"mechanicVectorData","type":"bytes"}],"name":"createEditionWithMechanicVector","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"defaultManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"editionCurrentSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"editionMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"editionStartId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"}],"name":"editionURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freezeMints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"}],"name":"getEditionDetails","outputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"size","type":"uint256"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"uint256","name":"initialTokenId","type":"uint256"}],"internalType":"struct IEditionCollection.EditionDetails","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getEditionId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEditionStartIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"editionIds","type":"uint256[]"}],"name":"getEditionsDetailsAndUri","outputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"size","type":"uint256"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"uint256","name":"initialTokenId","type":"uint256"}],"internalType":"struct IEditionCollection.EditionDetails[]","name":"","type":"tuple[]"},{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintAmountToRecipient","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"},{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintAmountToRecipients","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"mintOneToRecipient","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"},{"internalType":"address[]","name":"recipients","type":"address[]"}],"name":"mintOneToRecipients","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minters","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"observability","outputs":[{"internalType":"contract IObservability","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFiltererRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"registerMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeDefaultTokenManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"removeGranularTokenManagers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeRoyaltyManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newName","type":"string"},{"internalType":"string","name":"newSymbol","type":"string"},{"internalType":"string","name":"newContractUri","type":"string"}],"name":"setContractMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"internalType":"struct IRoyaltyManager.Royalty","name":"_royalty","type":"tuple"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_defaultTokenManager","type":"address"}],"name":"setDefaultTokenManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"editionId","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setEditionURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"components":[{"internalType":"address","name":"recipientAddress","type":"address"},{"internalType":"uint16","name":"royaltyPercentageBPS","type":"uint16"}],"internalType":"struct IRoyaltyManager.Royalty[]","name":"_newRoyalties","type":"tuple[]"}],"name":"setGranularRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"address[]","name":"_tokenManagers","type":"address[]"}],"name":"setGranularTokenManagers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"},{"internalType":"address","name":"subscription","type":"address"}],"name":"setRegistryAndSubscription","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_royaltyManager","type":"address"}],"name":"setRoyaltyManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenManager","outputs":[{"internalType":"address","name":"manager","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenManagerByTokenId","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"unregisterMinter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.