[ERC721C] オンチェーンロイヤリティを強制化する仕組みを理解しよう！

import "../../contracts/erc721c/ERC721C.sol";

contract MyERC721CCollection is ERC721C {

    constructor() ERC721C("Name of My Collection", "SYMBOL") {
        setToDefaultSecurityPolicy();
    }

    // TODO: Implement/Override base uri
    // TODO: Implement public minting function(s)
    // TODO: Implement EIP-2981 Royalties
    // TODO: Your other contract features, if any
}

abstract contract BasicRoyalties is ERC2981 {

    event DefaultRoyaltySet(address indexed receiver, uint96 feeNumerator);
    event TokenRoyaltySet(uint256 indexed tokenId, address indexed receiver, uint96 feeNumerator);

    constructor(address receiver, uint96 feeNumerator) {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual override {
        super._setDefaultRoyalty(receiver, feeNumerator);
        emit DefaultRoyaltySet(receiver, feeNumerator);
    }

    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual override {
        super._setTokenRoyalty(tokenId, receiver, feeNumerator);
        emit TokenRoyaltySet(tokenId, receiver, feeNumerator);
    }
}

abstract contract ImmutableMinterRoyalties is IERC2981, ERC165 {

    error ImmutableMinterRoyalties__MinterCannotBeZeroAddress();
    error ImmutableMinterRoyalties__MinterHasAlreadyBeenAssignedToTokenId();
    error ImmutableMinterRoyalties__RoyaltyFeeWillExceedSalePrice();

    uint256 public constant FEE_DENOMINATOR = 10_000;
    uint256 public immutable royaltyFeeNumerator;

    mapping (uint256 => address) private _minters;

    constructor(uint256 royaltyFeeNumerator_) {
        if(royaltyFeeNumerator_ > FEE_DENOMINATOR) {
            revert ImmutableMinterRoyalties__RoyaltyFeeWillExceedSalePrice();
        }

        royaltyFeeNumerator = royaltyFeeNumerator_;
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }

    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view override returns (address receiver, uint256 royaltyAmount) {
        return (_minters[tokenId], (salePrice * royaltyFeeNumerator) / FEE_DENOMINATOR);
    }

    function _onMinted(address minter, uint256 tokenId) internal {
        if (minter == address(0)) {
            revert ImmutableMinterRoyalties__MinterCannotBeZeroAddress();
        }

        if (_minters[tokenId] != address(0)) {
            revert ImmutableMinterRoyalties__MinterHasAlreadyBeenAssignedToTokenId();
        }

        _minters[tokenId] = minter;
    }

    function _onBurned(uint256 tokenId) internal {
        delete _minters[tokenId];
    }
}

abstract contract MinterCreatorSharedRoyalties is IERC2981, ERC165 {
    error MinterCreatorSharedRoyalties__RoyaltyFeeWillExceedSalePrice();
    error MinterCreatorSharedRoyalties__MinterCannotBeZeroAddress();
    error MinterCreatorSharedRoyalties__MinterHasAlreadyBeenAssignedToTokenId();
    error MinterCreatorSharedRoyalties__PaymentSplitterDoesNotExistForSpecifiedTokenId();

    enum ReleaseTo {
        Minter,
        Creator
    }

    uint256 public constant FEE_DENOMINATOR = 10_000;
    uint256 public immutable royaltyFeeNumerator;
    uint256 public immutable minterShares;
    uint256 public immutable creatorShares;
    address public immutable creator;

    mapping (uint256 => address) private _minters;
    mapping (uint256 => address) private _paymentSplitters;
    mapping (address => address[]) private _minterPaymentSplitters;

    constructor(uint256 royaltyFeeNumerator_, uint256 minterShares_, uint256 creatorShares_, address creator_) {
        if(royaltyFeeNumerator_ > FEE_DENOMINATOR) {
            revert MinterCreatorSharedRoyalties__RoyaltyFeeWillExceedSalePrice();
        }

        royaltyFeeNumerator = royaltyFeeNumerator_;
        minterShares = minterShares_;
        creatorShares = creatorShares_;
        creator = creator_;
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }

    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view override returns (address, uint256) {
        return (_paymentSplitters[tokenId], (salePrice * royaltyFeeNumerator) / FEE_DENOMINATOR);
    }

    function minterOf(uint256 tokenId) external view returns (address) {
        return _minters[tokenId];
    }

    function paymentSplitterOf(uint256 tokenId) external view returns (address) {
        return _paymentSplitters[tokenId];
    }

    function paymentSplittersOfMinter(address minter) external view returns (address[] memory) {
        return _minterPaymentSplitters[minter];
    }

    function releasableNativeFunds(uint256 tokenId, ReleaseTo releaseTo) external view returns (uint256) {
        PaymentSplitter paymentSplitter = _getPaymentSplitterForTokenOrRevert(tokenId);

        if (releaseTo == ReleaseTo.Minter) {
            return paymentSplitter.releasable(payable(_minters[tokenId]));
        } else {
            return paymentSplitter.releasable(payable(creator));
        }
    }

    function releasableERC20Funds(uint256 tokenId, address coin, ReleaseTo releaseTo) external view returns (uint256) {
        PaymentSplitter paymentSplitter = _getPaymentSplitterForTokenOrRevert(tokenId);

        if (releaseTo == ReleaseTo.Minter) {
            return paymentSplitter.releasable(IERC20(coin), _minters[tokenId]);
        } else {
            return paymentSplitter.releasable(IERC20(coin), creator);
        }
    }

    function releaseNativeFunds(uint256 tokenId, ReleaseTo releaseTo) external {
        PaymentSplitter paymentSplitter = _getPaymentSplitterForTokenOrRevert(tokenId);

        if (releaseTo == ReleaseTo.Minter) {
            paymentSplitter.release(payable(_minters[tokenId]));
        } else {
            paymentSplitter.release(payable(creator));
        }
    }

    function releaseERC20Funds(uint256 tokenId, address coin, ReleaseTo releaseTo) external {
        PaymentSplitter paymentSplitter = _getPaymentSplitterForTokenOrRevert(tokenId);

        if(releaseTo == ReleaseTo.Minter) {
            paymentSplitter.release(IERC20(coin), _minters[tokenId]);
        } else {
            paymentSplitter.release(IERC20(coin), creator);
        }
    }

    function _onMinted(address minter, uint256 tokenId) internal {
        if (minter == address(0)) {
            revert MinterCreatorSharedRoyalties__MinterCannotBeZeroAddress();
        }

        if (_minters[tokenId] != address(0)) {
            revert MinterCreatorSharedRoyalties__MinterHasAlreadyBeenAssignedToTokenId();
        }

        address paymentSplitter = _createPaymentSplitter(minter);
        _paymentSplitters[tokenId] = paymentSplitter;
        _minterPaymentSplitters[minter].push(paymentSplitter);
        _minters[tokenId] = minter;
    }

    function _onBurned(uint256 tokenId) internal {
        delete _paymentSplitters[tokenId];
        delete _minters[tokenId];
    }

    function _createPaymentSplitter(address minter) private returns (address) {
        if (minter == creator) {
            address[] memory payees = new address[](1);
            payees[0] = creator;

            uint256[] memory shares = new uint256[](1);
            shares[0] = minterShares + creatorShares;

            return address(new PaymentSplitter(payees, shares));
        } else {
            address[] memory payees = new address[](2);
            payees[0] = minter;
            payees[1] = creator;

            uint256[] memory shares = new uint256[](2);
            shares[0] = minterShares;
            shares[1] = creatorShares;

            return address(new PaymentSplitter(payees, shares));
        }
    }

    function _getPaymentSplitterForTokenOrRevert(uint256 tokenId) private view returns (PaymentSplitter) {
        address paymentSplitterForToken = _paymentSplitters[tokenId];
        if(paymentSplitterForToken == address(0)) {
            revert MinterCreatorSharedRoyalties__PaymentSplitterDoesNotExistForSpecifiedTokenId();
        }

        return PaymentSplitter(payable(paymentSplitterForToken));
    }
}

interface ICloneableRoyaltyRightsERC721 is IERC721 {
    function initializeAndBindToCollection() external;
    function mint(address to, uint256 tokenId) external;
    function burn(uint256 tokenId) external;
}

abstract contract MinterRoyaltiesReassignableRightsNFT is IERC2981, ERC165 {

    error MinterRoyaltiesReassignableRightsNFT__MinterCannotBeZeroAddress();
    error MinterRoyaltiesReassignableRightsNFT__RoyaltyFeeWillExceedSalePrice();

    uint256 public constant FEE_DENOMINATOR = 10_000;
    uint256 public immutable royaltyFeeNumerator;
    ICloneableRoyaltyRightsERC721 public immutable royaltyRightsNFT;

    constructor(uint256 royaltyFeeNumerator_, address royaltyRightsNFTReference_) {
        if(royaltyFeeNumerator_ > FEE_DENOMINATOR) {
            revert MinterRoyaltiesReassignableRightsNFT__RoyaltyFeeWillExceedSalePrice();
        }

        royaltyFeeNumerator = royaltyFeeNumerator_;


        ICloneableRoyaltyRightsERC721 royaltyRightsNFT_ = 
            ICloneableRoyaltyRightsERC721(Clones.clone(royaltyRightsNFTReference_));
        royaltyRightsNFT_.initializeAndBindToCollection();

        royaltyRightsNFT = royaltyRightsNFT_;
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }

    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view override returns (address receiver, uint256 royaltyAmount) {

        address rightsHolder = address(0);

        try royaltyRightsNFT.ownerOf(tokenId) returns (address rightsTokenOwner) {
            rightsHolder = rightsTokenOwner;
        } catch {}

        return (rightsHolder, (salePrice * royaltyFeeNumerator) / FEE_DENOMINATOR);
    }

    function _onMinted(address minter, uint256 tokenId) internal {
        if (minter == address(0)) {
            revert MinterRoyaltiesReassignableRightsNFT__MinterCannotBeZeroAddress();
        }

        royaltyRightsNFT.mint(minter, tokenId);
    }

    function _onBurned(uint256 tokenId) internal {
        royaltyRightsNFT.burn(tokenId);
    }
}

contract RoyaltyRightsNFT is ERC721, ICloneableRoyaltyRightsERC721 {

    error RoyaltyRightsNFT__CollectionAlreadyInitialized();
    error RoyaltyRightsNFT__OnlyBurnableFromCollection();
    error RoyaltyRightsNFT__OnlyMintableFromCollection();

    IERC721Metadata public collection;

    constructor() ERC721("", "") {}

    function initializeAndBindToCollection() external override {
        if (address(collection) != address(0)) {
            revert RoyaltyRightsNFT__CollectionAlreadyInitialized();
        }

        collection = IERC721Metadata(_msgSender());
    }

    function mint(address to, uint256 tokenId) external override {
        if (_msgSender() != address(collection)) {
            revert RoyaltyRightsNFT__OnlyMintableFromCollection();
        }

        _mint(to, tokenId);
    }

    function burn(uint256 tokenId) external override {
        if (_msgSender() != address(collection)) {
            revert RoyaltyRightsNFT__OnlyBurnableFromCollection();
        }

        _burn(tokenId);
    }

    function name() public view virtual override returns (string memory) {
        return string(abi.encodePacked(collection.name(), " Royalty Rights"));
    }

    function symbol() public view virtual override returns (string memory) {
        return string(abi.encodePacked(collection.symbol(), "RR"));
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        return collection.tokenURI(tokenId);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@limitbreak/creator-token-contracts/contracts
/erc721c/ERC721C.sol";
import "@limitbreak/creator-token-contracts/contracts
/programmable-royalties/ImmutableMinterRoyalties.sol";

contract ERC721CWithImmutableMinterRoyalties is ERC721C, ImmutableMinterRoyalties {

    constructor(
        uint256 royaltyFeeNumerator_,
        string memory name_,
        string memory symbol_) 
        ERC721C(name_, symbol_) 
        ImmutableMinterRoyalties(royaltyFeeNumerator_) {
        setToDefaultSecurityPolicy();
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721C, ImmutableMinterRoyalties) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function mint(address to, uint256 tokenId) external {
        _mint(to, tokenId);
    }

    function safeMint(address to, uint256 tokenId) external {
        _safeMint(to, tokenId);
    }

    function burn(uint256 tokenId) external {
        _burn(tokenId);
    }

    function _mint(address to, uint256 tokenId) internal virtual override {
        _onMinted(to, tokenId);
        super._mint(to, tokenId);
    }

    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);
        _onBurned(tokenId);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "../utils/CreatorTokenBase.sol";
import "../token/erc721/ERC721OpenZeppelin.sol";

/**
 * @title ERC721C
 * @author Limit Break, Inc.
 * @notice Extends OpenZeppelin's ERC721 implementation with Creator Token functionality, which
 *         allows the contract owner to update the transfer validation logic by managing a security policy in
 *         an external transfer validation security policy registry.  See {CreatorTokenTransferValidator}.
 */
abstract contract ERC721C is ERC721OpenZeppelin, CreatorTokenBase {

    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(ICreatorToken).interfaceId || super.supportsInterface(interfaceId);
    }

    /// @dev Ties the open-zeppelin _beforeTokenTransfer hook to more granular transfer validation logic
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize) internal virtual override {
        for (uint256 i = 0; i < batchSize;) {
            _validateBeforeTransfer(from, to, firstTokenId + i);
            unchecked {
                ++i;
            }
        }
    }

    /// @dev Ties the open-zeppelin _afterTokenTransfer hook to more granular transfer validation logic
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize) internal virtual override {
        for (uint256 i = 0; i < batchSize;) {
            _validateAfterTransfer(from, to, firstTokenId + i);
            unchecked {
                ++i;
            }
        }
    }
}

/**
 * @title ERC721CInitializable
 * @author Limit Break, Inc.
 * @notice Initializable implementation of ERC721C to allow for EIP-1167 proxy clones.
 */
abstract contract ERC721CInitializable is ERC721OpenZeppelinInitializable, CreatorTokenBase {
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(ICreatorToken).interfaceId || super.supportsInterface(interfaceId);
    }

    /// @dev Ties the open-zeppelin _beforeTokenTransfer hook to more granular transfer validation logic
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize) internal virtual override {
        for (uint256 i = 0; i < batchSize;) {
            _validateBeforeTransfer(from, to, firstTokenId + i);
            unchecked {
                ++i;
            }
        }
    }

    /// @dev Ties the open-zeppelin _afterTokenTransfer hook to more granular transfer validation logic
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize) internal virtual override {
        for (uint256 i = 0; i < batchSize;) {
            _validateAfterTransfer(from, to, firstTokenId + i);
            unchecked {
                ++i;
            }
        }
    }
}

_validateAfterTransfer(from, to, firstTokenId + i);

function _validateBeforeTransfer(address from, address to, uint256 tokenId) internal virtual {
    bool fromZeroAddress = from == address(0);
    bool toZeroAddress = to == address(0);

    if(fromZeroAddress && toZeroAddress) {
        revert ShouldNotMintToBurnAddress();
    } else if(fromZeroAddress) {
        _preValidateMint(_msgSender(), to, tokenId, msg.value);
    } else if(toZeroAddress) {
        _preValidateBurn(_msgSender(), from, tokenId, msg.value);
    } else {
        _preValidateTransfer(_msgSender(), from, to, tokenId, msg.value);
    }
}

function _validateAfterTransfer(address from, address to, uint256 tokenId) internal virtual {
    bool fromZeroAddress = from == address(0);
    bool toZeroAddress = to == address(0);

    if(fromZeroAddress && toZeroAddress) {
        revert ShouldNotMintToBurnAddress();
    } else if(fromZeroAddress) {
        _postValidateMint(_msgSender(), to, tokenId, msg.value);
    } else if(toZeroAddress) {
        _postValidateBurn(_msgSender(), from, tokenId, msg.value);
    } else {
        _postValidateTransfer(_msgSender(), from, to, tokenId, msg.value);
    }
}

/// @dev Optional validation hook that fires before a mint
function _preValidateMint(address caller, address to, uint256 tokenId, uint256 value) internal virtual {}

/// @dev Optional validation hook that fires after a mint
function _postValidateMint(address caller, address to, uint256 tokenId, uint256 value) internal virtual {}

/// @dev Optional validation hook that fires before a burn
function _preValidateBurn(address caller, address from, uint256 tokenId, uint256 value) internal virtual {}

/// @dev Optional validation hook that fires after a burn
function _postValidateBurn(address caller, address from, uint256 tokenId, uint256 value) internal virtual {}

/// @dev Optional validation hook that fires before a transfer
function _preValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 value) internal virtual {}

/// @dev Optional validation hook that fires after a transfer
function _postValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 value) internal virtual {}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import "../../access/OwnablePermissions.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

abstract contract ERC721OpenZeppelinBase is ERC721 {

    // Token name
    string internal _contractName;

    // Token symbol
    string internal _contractSymbol;

    function name() public view virtual override returns (string memory) {
        return _contractName;
    }

    function symbol() public view virtual override returns (string memory) {
        return _contractSymbol;
    }

    function _setNameAndSymbol(string memory name_, string memory symbol_) internal {
        _contractName = name_;
        _contractSymbol = symbol_;
    }
}

abstract contract ERC721OpenZeppelin is ERC721OpenZeppelinBase {
    constructor(string memory name_, string memory symbol_) ERC721("", "") {
        _setNameAndSymbol(name_, symbol_);
    }
}

abstract contract ERC721OpenZeppelinInitializable is OwnablePermissions, ERC721OpenZeppelinBase {

    error ERC721OpenZeppelinInitializable__AlreadyInitializedERC721();

    /// @notice Specifies whether or not the contract is initialized
    bool private _erc721Initialized;

    /// @dev Initializes parameters of ERC721 tokens.
    /// These cannot be set in the constructor because this contract is optionally compatible with EIP-1167.
    function initializeERC721(string memory name_, string memory symbol_) public {
        _requireCallerIsContractOwner();

        if(_erc721Initialized) {
            revert ERC721OpenZeppelinInitializable__AlreadyInitializedERC721();
        }

        _erc721Initialized = true;

        _setNameAndSymbol(name_, symbol_);
    }
}

address public constant DEFAULT_TRANSFER_VALIDATOR = address(0x0000721C310194CcfC01E523fc93C9cCcFa2A0Ac);

TransferSecurityLevels public constant DEFAULT_TRANSFER_SECURITY_LEVEL = TransferSecurityLevels.One;

uint120 public constant DEFAULT_OPERATOR_WHITELIST_ID = uint120(1);

ICreatorTokenTransferValidator private transferValidator;

function setToDefaultSecurityPolicy() public virtual {
    _requireCallerIsContractOwner();
    setTransferValidator(DEFAULT_TRANSFER_VALIDATOR);
    ICreatorTokenTransferValidator(DEFAULT_TRANSFER_VALIDATOR).setTransferSecurityLevelOfCollection(address(this), DEFAULT_TRANSFER_SECURITY_LEVEL);
    ICreatorTokenTransferValidator(DEFAULT_TRANSFER_VALIDATOR).setOperatorWhitelistOfCollection(address(this), DEFAULT_OPERATOR_WHITELIST_ID);
}

function setToCustomValidatorAndSecurityPolicy(
    address validator, 
    TransferSecurityLevels level, 
    uint120 operatorWhitelistId, 
    uint120 permittedContractReceiversAllowlistId) public {
    _requireCallerIsContractOwner();

    setTransferValidator(validator);

    ICreatorTokenTransferValidator(validator).
        setTransferSecurityLevelOfCollection(address(this), level);

    ICreatorTokenTransferValidator(validator).
        setOperatorWhitelistOfCollection(address(this), operatorWhitelistId);

    ICreatorTokenTransferValidator(validator).
        setPermittedContractReceiverAllowlistOfCollection(address(this), permittedContractReceiversAllowlistId);
}

function setToCustomSecurityPolicy(
    TransferSecurityLevels level, 
    uint120 operatorWhitelistId, 
    uint120 permittedContractReceiversAllowlistId) public {
    _requireCallerIsContractOwner();

    ICreatorTokenTransferValidator validator = getTransferValidator();
    if (address(validator) == address(0)) {
        revert CreatorTokenBase__SetTransferValidatorFirst();
    }

    validator.setTransferSecurityLevelOfCollection(address(this), level);
    validator.setOperatorWhitelistOfCollection(address(this), operatorWhitelistId);
    validator.setPermittedContractReceiverAllowlistOfCollection(address(this), permittedContractReceiversAllowlistId);
}

function setTransferValidator(address transferValidator_) public {
    _requireCallerIsContractOwner();

    bool isValidTransferValidator = false;

    if (transferValidator_.code.length > 0) {
        try IERC165(transferValidator_).supportsInterface(type(ICreatorTokenTransferValidator).interfaceId) 
            returns (bool supportsInterface) {
            isValidTransferValidator = supportsInterface;
        } catch {}
    }

    if (transferValidator_ != address(0) && !isValidTransferValidator) {
        revert CreatorTokenBase__InvalidTransferValidatorContract();
    }

    emit TransferValidatorUpdated(address(transferValidator), transferValidator_);

    transferValidator = ICreatorTokenTransferValidator(transferValidator_);
}

function getTransferValidator() public view override returns (ICreatorTokenTransferValidator) {
    return transferValidator;
}

function getSecurityPolicy() public view override returns (CollectionSecurityPolicy memory) {
    if (address(transferValidator) != address(0)) {
        return transferValidator.getCollectionSecurityPolicy(address(this));
    }

    return CollectionSecurityPolicy({
        transferSecurityLevel: TransferSecurityLevels.Zero,
        operatorWhitelistId: 0,
        permittedContractReceiversId: 0
    });
}

function getWhitelistedOperators() public view override returns (address[] memory) {
    if (address(transferValidator) != address(0)) {
        return transferValidator.getWhitelistedOperators(
            transferValidator.getCollectionSecurityPolicy(address(this)).operatorWhitelistId);
    }

    return new address[](0);
}

function getPermittedContractReceivers() public view override returns (address[] memory) {
    if (address(transferValidator) != address(0)) {
        return transferValidator.getPermittedContractReceivers(
            transferValidator.getCollectionSecurityPolicy(address(this)).permittedContractReceiversId);
    }

    return new address[](0);
}

function isOperatorWhitelisted(address operator) public view override returns (bool) {
    if (address(transferValidator) != address(0)) {
        return transferValidator.isOperatorWhitelisted(
            transferValidator.getCollectionSecurityPolicy(address(this)).operatorWhitelistId, operator);
    }

    return false;
}

function isContractReceiverPermitted(address receiver) public view override returns (bool) {
    if (address(transferValidator) != address(0)) {
        return transferValidator.isContractReceiverPermitted(
            transferValidator.getCollectionSecurityPolicy(address(this)).permittedContractReceiversId, receiver);
    }

    return false;
}

function isTransferAllowed(address caller, address from, address to) public view override returns (bool) {
    if (address(transferValidator) != address(0)) {
        try transferValidator.applyCollectionTransferPolicy(caller, from, to) {
            return true;
        } catch {
            return false;
        }
    }
    return true;
}

function _preValidateTransfer(
    address caller, 
    address from, 
    address to, 
    uint256 /*tokenId*/, 
    uint256 /*value*/) internal virtual override {
    if (address(transferValidator) != address(0)) {
        transferValidator.applyCollectionTransferPolicy(caller, from, to);
    }
}

bytes32 private constant DEFAULT_ACCESS_CONTROL_ADMIN_ROLE = 0x00;

TransferSecurityLevels public constant DEFAULT_TRANSFER_SECURITY_LEVEL = TransferSecurityLevels.Zero;

uint120 private lastOperatorWhitelistId;

uint120 private lastPermittedContractReceiverAllowlistId;

mapping (TransferSecurityLevels => TransferSecurityPolicy) public transferSecurityPolicies;

mapping (address => CollectionSecurityPolicy) private collectionSecurityPolicies;

mapping (uint120 => address) public operatorWhitelistOwners;

mapping (uint120 => address) public permittedContractReceiverAllowlistOwners;

mapping (uint120 => EnumerableSet.AddressSet) private operatorWhitelists;

mapping (uint120 => EnumerableSet.AddressSet) private permittedContractReceiverAllowlists;

constructor(address defaultOwner) EOARegistry() {
    transferSecurityPolicies[TransferSecurityLevels.Zero] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.None,
        receiverConstraints: ReceiverConstraints.None
    });

    transferSecurityPolicies[TransferSecurityLevels.One] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistEnableOTC,
        receiverConstraints: ReceiverConstraints.None
    });

    transferSecurityPolicies[TransferSecurityLevels.Two] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistDisableOTC,
        receiverConstraints: ReceiverConstraints.None
    });

    transferSecurityPolicies[TransferSecurityLevels.Three] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistEnableOTC,
        receiverConstraints: ReceiverConstraints.NoCode
    });

    transferSecurityPolicies[TransferSecurityLevels.Four] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistEnableOTC,
        receiverConstraints: ReceiverConstraints.EOA
    });

    transferSecurityPolicies[TransferSecurityLevels.Five] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistDisableOTC,
        receiverConstraints: ReceiverConstraints.NoCode
    });

    transferSecurityPolicies[TransferSecurityLevels.Six] = TransferSecurityPolicy({
        callerConstraints: CallerConstraints.OperatorWhitelistDisableOTC,
        receiverConstraints: ReceiverConstraints.EOA
    });

    uint120 id = ++lastOperatorWhitelistId;

    operatorWhitelistOwners[id] = defaultOwner;

    emit CreatedAllowlist(AllowlistTypes.Operators, id, "DEFAULT OPERATOR WHITELIST");
    emit ReassignedAllowlistOwnership(AllowlistTypes.Operators, id, defaultOwner);
}

function applyCollectionTransferPolicy(address caller, address from, address to) external view override {
    address collection = _msgSender();
    CollectionSecurityPolicy memory collectionSecurityPolicy = collectionSecurityPolicies[collection];
    TransferSecurityPolicy memory transferSecurityPolicy = 
        transferSecurityPolicies[collectionSecurityPolicy.transferSecurityLevel];
    
    if (transferSecurityPolicy.receiverConstraints == ReceiverConstraints.NoCode) {
        if (to.code.length > 0) {
            if (!isContractReceiverPermitted(collectionSecurityPolicy.permittedContractReceiversId, to)) {
                revert CreatorTokenTransferValidator__ReceiverMustNotHaveDeployedCode();
            }
        }
    } else if (transferSecurityPolicy.receiverConstraints == ReceiverConstraints.EOA) {
        if (!isVerifiedEOA(to)) {
            if (!isContractReceiverPermitted(collectionSecurityPolicy.permittedContractReceiversId, to)) {
                revert CreatorTokenTransferValidator__ReceiverProofOfEOASignatureUnverified();
            }
        }
    }

    if (transferSecurityPolicy.callerConstraints != CallerConstraints.None) {
        if(operatorWhitelists[collectionSecurityPolicy.operatorWhitelistId].length() > 0) {
            if (!isOperatorWhitelisted(collectionSecurityPolicy.operatorWhitelistId, caller)) {
                if (transferSecurityPolicy.callerConstraints == CallerConstraints.OperatorWhitelistEnableOTC) {
                    if (caller != from) {
                        revert CreatorTokenTransferValidator__CallerMustBeWhitelistedOperator();
                    }
                } else {
                    revert CreatorTokenTransferValidator__CallerMustBeWhitelistedOperator();
                }
            }
        }
    }
}

function createOperatorWhitelist(string calldata name) external override returns (uint120) {
    uint120 id = ++lastOperatorWhitelistId;

    operatorWhitelistOwners[id] = _msgSender();

    emit CreatedAllowlist(AllowlistTypes.Operators, id, name);
    emit ReassignedAllowlistOwnership(AllowlistTypes.Operators, id, _msgSender());

    return id;
}

function createPermittedContractReceiverAllowlist(string calldata name) external override returns (uint120) {
    uint120 id = ++lastPermittedContractReceiverAllowlistId;

    permittedContractReceiverAllowlistOwners[id] = _msgSender();

    emit CreatedAllowlist(AllowlistTypes.PermittedContractReceivers, id, name);
    emit ReassignedAllowlistOwnership(AllowlistTypes.PermittedContractReceivers, id, _msgSender());

    return id;
}

function reassignOwnershipOfOperatorWhitelist(uint120 id, address newOwner) external override {
    if(newOwner == address(0)) {
        revert CreatorTokenTransferValidator__AllowlistOwnershipCannotBeTransferredToZeroAddress();
    }

    _reassignOwnershipOfOperatorWhitelist(id, newOwner);
}

function reassignOwnershipOfPermittedContractReceiverAllowlist(uint120 id, address newOwner) external override {
    if(newOwner == address(0)) {
        revert CreatorTokenTransferValidator__AllowlistOwnershipCannotBeTransferredToZeroAddress();
    }

    _reassignOwnershipOfPermittedContractReceiverAllowlist(id, newOwner);
}

function renounceOwnershipOfOperatorWhitelist(uint120 id) external override {
    _reassignOwnershipOfOperatorWhitelist(id, address(0));
}

function renounceOwnershipOfPermittedContractReceiverAllowlist(uint120 id) external override {
    _reassignOwnershipOfPermittedContractReceiverAllowlist(id, address(0));
}

function setTransferSecurityLevelOfCollection(
    address collection, 
    TransferSecurityLevels level) external override {
    _requireCallerIsNFTOrContractOwnerOrAdmin(collection);
    collectionSecurityPolicies[collection].transferSecurityLevel = level;
    emit SetTransferSecurityLevel(collection, level);
}

function setOperatorWhitelistOfCollection(address collection, uint120 id) external override {
    _requireCallerIsNFTOrContractOwnerOrAdmin(collection);

    if (id > lastOperatorWhitelistId) {
        revert CreatorTokenTransferValidator__AllowlistDoesNotExist();
    }

    collectionSecurityPolicies[collection].operatorWhitelistId = id;
    emit SetAllowlist(AllowlistTypes.Operators, collection, id);
}

function setPermittedContractReceiverAllowlistOfCollection(address collection, uint120 id) external override {
    _requireCallerIsNFTOrContractOwnerOrAdmin(collection);

    if (id > lastPermittedContractReceiverAllowlistId) {
        revert CreatorTokenTransferValidator__AllowlistDoesNotExist();
    }

    collectionSecurityPolicies[collection].permittedContractReceiversId = id;
    emit SetAllowlist(AllowlistTypes.PermittedContractReceivers, collection, id);
}

function addOperatorToWhitelist(uint120 id, address operator) external override {
    _requireCallerOwnsOperatorWhitelist(id);

    if (!operatorWhitelists[id].add(operator)) {
        revert CreatorTokenTransferValidator__AddressAlreadyAllowed();
    }

    emit AddedToAllowlist(AllowlistTypes.Operators, id, operator);
}

function addPermittedContractReceiverToAllowlist(uint120 id, address receiver) external override {
    _requireCallerOwnsPermittedContractReceiverAllowlist(id);

    if (!permittedContractReceiverAllowlists[id].add(receiver)) {
        revert CreatorTokenTransferValidator__AddressAlreadyAllowed();
    }

    emit AddedToAllowlist(AllowlistTypes.PermittedContractReceivers, id, receiver);
}

function removeOperatorFromWhitelist(uint120 id, address operator) external override {
    _requireCallerOwnsOperatorWhitelist(id);

    if (!operatorWhitelists[id].remove(operator)) {
        revert CreatorTokenTransferValidator__AddressNotAllowed();
    }

    emit RemovedFromAllowlist(AllowlistTypes.Operators, id, operator);
}

function removePermittedContractReceiverFromAllowlist(uint120 id, address receiver) external override {
    _requireCallerOwnsPermittedContractReceiverAllowlist(id);

    if (!permittedContractReceiverAllowlists[id].remove(receiver)) {
        revert CreatorTokenTransferValidator__AddressNotAllowed();
    }

    emit RemovedFromAllowlist(AllowlistTypes.PermittedContractReceivers, id, receiver);
}

function getCollectionSecurityPolicy(address collection) 
    external view override returns (CollectionSecurityPolicy memory) {
    return collectionSecurityPolicies[collection];
}

function getWhitelistedOperators(uint120 id) external view override returns (address[] memory) {
    return operatorWhitelists[id].values();
}

function getPermittedContractReceivers(uint120 id) external view override returns (address[] memory) {
    return permittedContractReceiverAllowlists[id].values();
}

function isOperatorWhitelisted(uint120 id, address operator) public view override returns (bool) {
    return operatorWhitelists[id].contains(operator);
}

function isContractReceiverPermitted(uint120 id, address receiver) public view override returns (bool) {
    return permittedContractReceiverAllowlists[id].contains(receiver);
}

function supportsInterface(bytes4 interfaceId) public view virtual override(EOARegistry, IERC165) returns (bool) {
    return
        interfaceId == type(ITransferValidator).interfaceId ||
        interfaceId == type(ITransferSecurityRegistry).interfaceId ||
        interfaceId == type(ICreatorTokenTransferValidator).interfaceId ||
        super.supportsInterface(interfaceId);
}

function _requireCallerIsNFTOrContractOwnerOrAdmin(address tokenAddress) internal view {
    bool callerHasPermissions = false;
    if(tokenAddress.code.length > 0) {
        callerHasPermissions = _msgSender() == tokenAddress;
        if(!callerHasPermissions) {

            try IOwnable(tokenAddress).owner() returns (address contractOwner) {
                callerHasPermissions = _msgSender() == contractOwner;
            } catch {}

            if(!callerHasPermissions) {
                try IAccessControl(tokenAddress).hasRole(DEFAULT_ACCESS_CONTROL_ADMIN_ROLE, _msgSender()) 
                    returns (bool callerIsContractAdmin) {
                    callerHasPermissions = callerIsContractAdmin;
                } catch {}
            }
        }
    }

    if(!callerHasPermissions) {
        revert CreatorTokenTransferValidator__CallerMustHaveElevatedPermissionsForSpecifiedNFT();
    }
}

function _reassignOwnershipOfOperatorWhitelist(uint120 id, address newOwner) private {
    _requireCallerOwnsOperatorWhitelist(id);
    operatorWhitelistOwners[id] = newOwner;
    emit ReassignedAllowlistOwnership(AllowlistTypes.Operators, id, newOwner);
}

function _reassignOwnershipOfPermittedContractReceiverAllowlist(uint120 id, address newOwner) private {
    _requireCallerOwnsPermittedContractReceiverAllowlist(id);
    permittedContractReceiverAllowlistOwners[id] = newOwner;
    emit ReassignedAllowlistOwnership(AllowlistTypes.PermittedContractReceivers, id, newOwner);
}

function _requireCallerOwnsOperatorWhitelist(uint120 id) private view {
    if (_msgSender() != operatorWhitelistOwners[id]) {
        revert CreatorTokenTransferValidator__CallerDoesNotOwnAllowlist();
    }
}

function _requireCallerOwnsPermittedContractReceiverAllowlist(uint120 id) private view {
    if (_msgSender() != permittedContractReceiverAllowlistOwners[id]) {
        revert CreatorTokenTransferValidator__CallerDoesNotOwnAllowlist();
    }
}