[ERC7401] NFTでネスト構造を作るERC6059をアップデートした仕組みを理解しよう！

/// @title EIP-7401 Parent-Governed Nestable Non-Fungible Tokens
/// @dev See https://eips.ethereum.org/EIPS/eip-7401
/// @dev Note: the ERC-165 identifier for this interface is 0x42b0e56f.

pragma solidity ^0.8.16;

interface IERC7059 /* is ERC165 */ {
    /**
     * @notice The core struct of ownership.
     * @dev The `DirectOwner` struct is used to store information of the next immediate owner, be it the parent token,
     * an `ERC721Receiver` contract or an externally owned account.
     * @dev If the token is not owned by an NFT, the `tokenId` MUST equal `0`.
     * @param tokenId ID of the parent token
     * @param ownerAddress Address of the owner of the token. If the owner is another token, then the address MUST be
     *  the one of the parent token's collection smart contract. If the owner is externally owned account, the address
     *  MUST be the address of this account
     */
    struct DirectOwner {
        uint256 tokenId;
        address ownerAddress;
    }

    /**
     * @notice The core child token struct, holding the information about the child tokens.
     * @return tokenId ID of the child token in the child token's collection smart contract
     * @return contractAddress Address of the child token's smart contract
     */
    struct Child {
        uint256 tokenId;
        address contractAddress;
    }

    /**
     * @notice Used to notify listeners that the token is being transferred.
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     * @param from Address of the previous immediate owner, which is a smart contract if the token was nested.
     * @param to Address of the new immediate owner, which is a smart contract if the token is being nested.
     * @param fromTokenId ID of the previous parent token. If the token was not nested before, the value MUST be `0`
     * @param toTokenId ID of the new parent token. If the token is not being nested, the value MUST be `0`
     * @param tokenId ID of the token being transferred
     */
    event NestTransfer(
        address indexed from,
        address indexed to,
        uint256 fromTokenId,
        uint256 toTokenId,
        uint256 indexed tokenId
    );

    /**
     * @notice Used to notify listeners that a new token has been added to a given token's pending children array.
     * @dev Emitted when a child NFT is added to a token's pending array.
     * @param tokenId ID of the token that received a new pending child token
     * @param childIndex Index of the proposed child token in the parent token's pending children array
     * @param childAddress Address of the proposed child token's collection smart contract
     * @param childId ID of the child token in the child token's collection smart contract
     */
    event ChildProposed(
        uint256 indexed tokenId,
        uint256 childIndex,
        address indexed childAddress,
        uint256 indexed childId
    );

    /**
     * @notice Used to notify listeners that a new child token was accepted by the parent token.
     * @dev Emitted when a parent token accepts a token from its pending array, migrating it to the active array.
     * @param tokenId ID of the token that accepted a new child token
     * @param childIndex Index of the newly accepted child token in the parent token's active children array
     * @param childAddress Address of the child token's collection smart contract
     * @param childId ID of the child token in the child token's collection smart contract
     */
    event ChildAccepted(
        uint256 indexed tokenId,
        uint256 childIndex,
        address indexed childAddress,
        uint256 indexed childId
    );

    /**
     * @notice Used to notify listeners that all pending child tokens of a given token have been rejected.
     * @dev Emitted when a token removes all a child tokens from its pending array.
     * @param tokenId ID of the token that rejected all of the pending children
     */
    event AllChildrenRejected(uint256 indexed tokenId);

    /**
     * @notice Used to notify listeners a child token has been transferred from parent token.
     * @dev Emitted when a token transfers a child from itself, transferring ownership.
     * @param tokenId ID of the token that transferred a child token
     * @param childIndex Index of a child in the array from which it is being transferred
     * @param childAddress Address of the child token's collection smart contract
     * @param childId ID of the child token in the child token's collection smart contract
     * @param fromPending A boolean value signifying whether the token was in the pending child tokens array (`true`) or
     *  in the active child tokens array (`false`)
     * @param toZero A boolean value signifying whether the token is being transferred to the `0x0` address (`true`) or
     *  not (`false`)
     */
    event ChildTransferred(
        uint256 indexed tokenId,
        uint256 childIndex,
        address indexed childAddress,
        uint256 indexed childId,
        bool fromPending,
        bool toZero
    );

    /**
     * @notice Used to retrieve the *root* owner of a given token.
     * @dev The *root* owner of the token is the top-level owner in the hierarchy which is not an NFT.
     * @dev If the token is owned by another NFT, it MUST recursively look up the parent's root owner.
     * @param tokenId ID of the token for which the *root* owner has been retrieved
     * @return owner The *root* owner of the token
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @notice Used to retrieve the immediate owner of the given token.
     * @dev If the immediate owner is another token, the address returned, MUST be the one of the parent token's
     *  collection smart contract.
     * @param tokenId ID of the token for which the direct owner is being retrieved
     * @return address Address of the given token's owner
     * @return uint256 The ID of the parent token. MUST be `0` if the owner is not an NFT
     * @return bool The boolean value signifying whether the owner is an NFT or not
     */
    function directOwnerOf(uint256 tokenId)
        external
        view
        returns (
            address,
            uint256,
            bool
        );

    /**
     * @notice Used to burn a given token.
     * @dev When a token is burned, all of its child tokens are recursively burned as well.
     * @dev When specifying the maximum recursive burns, the execution MUST be reverted if there are more children to be
     *  burned.
     * @dev Setting the `maxRecursiveBurn` value to 0 SHOULD only attempt to burn the specified token and MUST revert if
     *  there are any child tokens present.
     * @param tokenId ID of the token to burn
     * @param maxRecursiveBurns Maximum number of tokens to recursively burn
     * @return uint256 Number of recursively burned children
     */
    function burn(uint256 tokenId, uint256 maxRecursiveBurns)
        external
        returns (uint256);

    /**
     * @notice Used to add a child token to a given parent token.
     * @dev This adds the child token into the given parent token's pending child tokens array.
     * @dev The destination token MUST NOT be a child token of the token being transferred or one of its downstream
     *  child tokens.
     * @dev This method MUST NOT be called directly. It MUST only be called from an instance of `IERC7059` as part of a 
        `nestTransfer` or `transferChild` to an NFT.
     * @dev Requirements:
     *
     *  - `directOwnerOf` on the child contract MUST resolve to the called contract.
     *  - the pending array of the parent contract MUST not be full.
     * @param parentId ID of the parent token to receive the new child token
     * @param childId ID of the new proposed child token
     */
    function addChild(uint256 parentId, uint256 childId) external;

    /**
     * @notice Used to accept a pending child token for a given parent token.
     * @dev This moves the child token from parent token's pending child tokens array into the active child tokens
     *  array.
     * @param parentId ID of the parent token for which the child token is being accepted
     * @param childIndex Index of the child token to accept in the pending children array of a given token
     * @param childAddress Address of the collection smart contract of the child token expected to be at the specified
     *  index
     * @param childId ID of the child token expected to be located at the specified index
     */
    function acceptChild(
        uint256 parentId,
        uint256 childIndex,
        address childAddress,
        uint256 childId
    ) external;

    /**
     * @notice Used to reject all pending children of a given parent token.
     * @dev Removes the children from the pending array mapping.
     * @dev The children's ownership structures are not updated.
     * @dev Requirements:
     *
     * - `parentId` MUST exist
     * @param parentId ID of the parent token for which to reject all of the pending tokens
     * @param maxRejections Maximum number of expected children to reject, used to prevent from
     *  rejecting children which arrive just before this operation.
     */
    function rejectAllChildren(uint256 parentId, uint256 maxRejections) external;

    /**
     * @notice Used to transfer a child token from a given parent token.
     * @dev MUST remove the child from the parent's active or pending children.
     * @dev When transferring a child token, the owner of the token MUST be set to `to`, or not updated in the event of `to`
     *  being the `0x0` address.
     * @param tokenId ID of the parent token from which the child token is being transferred
     * @param to Address to which to transfer the token to
     * @param destinationId ID of the token to receive this child token (MUST be 0 if the destination is not a token)
     * @param childIndex Index of a token we are transferring, in the array it belongs to (can be either active array or
     *  pending array)
     * @param childAddress Address of the child token's collection smart contract
     * @param childId ID of the child token in its own collection smart contract
     * @param isPending A boolean value indicating whether the child token being transferred is in the pending array of the
     *  parent token (`true`) or in the active array (`false`)
     * @param data Additional data with no specified format, sent in call to `to`
     */
    function transferChild(
        uint256 tokenId,
        address to,
        uint256 destinationId,
        uint256 childIndex,
        address childAddress,
        uint256 childId,
        bool isPending,
        bytes data
    ) external;

    /**
     * @notice Used to retrieve the active child tokens of a given parent token.
     * @dev Returns array of Child structs existing for parent token.
     * @dev The Child struct consists of the following values:
     *  [
     *      tokenId,
     *      contractAddress
     *  ]
     * @param parentId ID of the parent token for which to retrieve the active child tokens
     * @return struct[] An array of Child structs containing the parent token's active child tokens
     */
    function childrenOf(uint256 parentId)
        external
        view
        returns (Child[] memory);

    /**
     * @notice Used to retrieve the pending child tokens of a given parent token.
     * @dev Returns array of pending Child structs existing for given parent.
     * @dev The Child struct consists of the following values:
     *  [
     *      tokenId,
     *      contractAddress
     *  ]
     * @param parentId ID of the parent token for which to retrieve the pending child tokens
     * @return struct[] An array of Child structs containing the parent token's pending child tokens
     */
    function pendingChildrenOf(uint256 parentId)
        external
        view
        returns (Child[] memory);

    /**
     * @notice Used to retrieve a specific active child token for a given parent token.
     * @dev Returns a single Child struct locating at `index` of parent token's active child tokens array.
     * @dev The Child struct consists of the following values:
     *  [
     *      tokenId,
     *      contractAddress
     *  ]
     * @param parentId ID of the parent token for which the child is being retrieved
     * @param index Index of the child token in the parent token's active child tokens array
     * @return struct A Child struct containing data about the specified child
     */
    function childOf(uint256 parentId, uint256 index)
        external
        view
        returns (Child memory);

    /**
     * @notice Used to retrieve a specific pending child token from a given parent token.
     * @dev Returns a single Child struct locating at `index` of parent token's active child tokens array.
     * @dev The Child struct consists of the following values:
     *  [
     *      tokenId,
     *      contractAddress
     *  ]
     * @param parentId ID of the parent token for which the pending child token is being retrieved
     * @param index Index of the child token in the parent token's pending child tokens array
     * @return struct A Child struct containing data about the specified child
     */
    function pendingChildOf(uint256 parentId, uint256 index)
        external
        view
        returns (Child memory);

    /**
     * @notice Used to transfer the token into another token.
     * @dev The destination token MUST NOT be a child token of the token being transferred or one of its downstream
     *  child tokens.
     * @param from Address of the direct owner of the token to be transferred
     * @param to Address of the receiving token's collection smart contract
     * @param tokenId ID of the token being transferred
     * @param destinationId ID of the token to receive the token being transferred
     * @param data Additional data with no specified format
     */
    function nestTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        uint256 destinationId,
        bytes memory data
    ) external;
}

function transferChild(
    uint256 tokenId,
    address to,
    uint256 destinationId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes data
) external;

uint256 private constant _MAX_LEVELS_TO_CHECK_FOR_INHERITANCE_LOOP = 100;

mapping(address => uint256) private _balances;

mapping(uint256 => mapping(address => address)) private _tokenApprovals;

mapping(address => mapping(address => bool)) private _operatorApprovals;

mapping(uint256 => DirectOwner) private _directOwners;

mapping(uint256 => Child[]) internal _activeChildren;

mapping(uint256 => Child[]) internal _pendingChildren;

mapping(address => mapping(uint256 => uint256)) internal _childIsInActive;

function _onlyApprovedOrOwner(uint256 tokenId) private view {
    if (!_isApprovedOrOwner(_msgSender(), tokenId))
        revert ERC721NotApprovedOrOwner();
}

modifier onlyApprovedOrOwner(uint256 tokenId) {
    _onlyApprovedOrOwner(tokenId);
    _;
}

function _onlyApprovedOrDirectOwner(uint256 tokenId) private view {
    if (!_isApprovedOrDirectOwner(_msgSender(), tokenId))
        revert NotApprovedOrDirectOwner();
}

modifier onlyApprovedOrDirectOwner(uint256 tokenId) {
    _onlyApprovedOrDirectOwner(tokenId);
    _;
}

function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
    return
        interfaceId == type(IERC165).interfaceId ||
        interfaceId == type(IERC721).interfaceId ||
        interfaceId == type(IERC7401).interfaceId;
}

function balanceOf(address owner) public view virtual returns (uint256) {
    if (owner == address(0)) revert ERC721AddressZeroIsNotaValidOwner();
    return _balances[owner];
}

function transferFrom(
    address from,
    address to,
    uint256 tokenId
) public virtual onlyApprovedOrDirectOwner(tokenId) {
    _transfer(from, to, tokenId, "");
}

function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
) public virtual {
    safeTransferFrom(from, to, tokenId, "");
}

function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
) public virtual onlyApprovedOrDirectOwner(tokenId) {
    _safeTransfer(from, to, tokenId, data);
}

function nestTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    uint256 destinationId,
    bytes memory data
) public virtual onlyApprovedOrDirectOwner(tokenId) {

    _nestTransfer(from, to, tokenId, destinationId, data);
}

function _safeTransfer(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
) internal virtual {
    _transfer(from, to, tokenId, data);
    if (!_checkOnERC721Received(from, to, tokenId, data))
        revert ERC721TransferToNonReceiverImplementer();
}

function _transfer(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
) internal virtual {
    (address immediateOwner, uint256 parentId, ) = directOwnerOf(tokenId);
    if (immediateOwner != from) revert ERC721TransferFromIncorrectOwner();
    if (to == address(0)) revert ERC721TransferToTheZeroAddress();

    _beforeTokenTransfer(from, to, tokenId);
    _beforeNestedTokenTransfer(from, to, parentId, 0, tokenId, data);

    _balances[from] -= 1;
    _updateOwnerAndClearApprovals(tokenId, 0, to);
    _balances[to] += 1;

    emit Transfer(from, to, tokenId);
    emit NestTransfer(from, to, parentId, 0, tokenId);

    _afterTokenTransfer(from, to, tokenId);
    _afterNestedTokenTransfer(from, to, parentId, 0, tokenId, data);
}

function _nestTransfer(
    address from,
    address to,
    uint256 tokenId,
    uint256 destinationId,
    bytes memory data
) internal virtual {
    (address immediateOwner, uint256 parentId, ) = directOwnerOf(tokenId);
    if (immediateOwner != from) revert ERC721TransferFromIncorrectOwner();
    if (to == address(0)) revert ERC721TransferToTheZeroAddress();
    if (to == address(this) && tokenId == destinationId)
        revert NestableTransferToSelf();

    // Destination contract checks:
    // It seems redundant, but otherwise it would revert with no error
    if (!to.isContract()) revert IsNotContract();
    if (!IERC165(to).supportsInterface(type(IERC7401).interfaceId))
        revert NestableTransferToNonNestableImplementer();
    _checkForInheritanceLoop(tokenId, to, destinationId);

    _beforeTokenTransfer(from, to, tokenId);
    _beforeNestedTokenTransfer(
        immediateOwner,
        to,
        parentId,
        destinationId,
        tokenId,
        data
    );
    _balances[from] -= 1;
    _updateOwnerAndClearApprovals(tokenId, destinationId, to);
    _balances[to] += 1;

    // Sending to NFT:
    _sendToNFT(immediateOwner, to, parentId, destinationId, tokenId, data);
}

function _sendToNFT(
    address from,
    address to,
    uint256 parentId,
    uint256 destinationId,
    uint256 tokenId,
    bytes memory data
) private {
    IERC7401 destContract = IERC7401(to);
    destContract.addChild(destinationId, tokenId, data);

    emit Transfer(from, to, tokenId);
    emit NestTransfer(from, to, parentId, destinationId, tokenId);

    _afterTokenTransfer(from, to, tokenId);
    _afterNestedTokenTransfer(
        from,
        to,
        parentId,
        destinationId,
        tokenId,
        data
    );
}

function _checkForInheritanceLoop(
    uint256 currentId,
    address targetContract,
    uint256 targetId
) private view {
    for (uint256 i; i < _MAX_LEVELS_TO_CHECK_FOR_INHERITANCE_LOOP; ) {
        (
            address nextOwner,
            uint256 nextOwnerTokenId,
            bool isNft
        ) = IERC7401(targetContract).directOwnerOf(targetId);
        // If there's a final address, we're good. There's no loop.
        if (!isNft) {
            return;
        }
        // Ff the current nft is an ancestor at some point, there is an inheritance loop
        if (nextOwner == address(this) && nextOwnerTokenId == currentId) {
            revert NestableTransferToDescendant();
        }
        // We reuse the parameters to save some contract size
        targetContract = nextOwner;
        targetId = nextOwnerTokenId;
        unchecked {
            ++i;
        }
    }
    revert NestableTooDeep();
}

function _safeMint(
    address to,
    uint256 tokenId,
    bytes memory data
) internal virtual {
    _mint(to, tokenId, data);
    if (!_checkOnERC721Received(address(0), to, tokenId, data))
        revert ERC721TransferToNonReceiverImplementer();
}

function _mint(
    address to,
    uint256 tokenId,
    bytes memory data
) internal virtual {
    _innerMint(to, tokenId, 0, data);

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

    _afterTokenTransfer(address(0), to, tokenId);
    _afterNestedTokenTransfer(address(0), to, 0, 0, tokenId, data);
}

function _nestMint(
    address to,
    uint256 tokenId,
    uint256 destinationId,
    bytes memory data
) internal virtual {
    // It seems redundant, but otherwise it would revert with no error
    if (!to.isContract()) revert IsNotContract();
    if (!IERC165(to).supportsInterface(type(IERC7401).interfaceId))
        revert MintToNonNestableImplementer();

    _innerMint(to, tokenId, destinationId, data);
    _sendToNFT(address(0), to, 0, destinationId, tokenId, data);
}

function _innerMint(
    address to,
    uint256 tokenId,
    uint256 destinationId,
    bytes memory data
) private {
    if (to == address(0)) revert ERC721MintToTheZeroAddress();
    if (_exists(tokenId)) revert ERC721TokenAlreadyMinted();
    if (tokenId == uint256(0)) revert IdZeroForbidden();

    _beforeTokenTransfer(address(0), to, tokenId);
    _beforeNestedTokenTransfer(
        address(0),
        to,
        0,
        destinationId,
        tokenId,
        data
    );

    _balances[to] += 1;
    _directOwners[tokenId] = DirectOwner({
        ownerAddress: to,
        tokenId: destinationId
    });
}

function ownerOf(
    uint256 tokenId
) public view virtual override(IERC7401, IERC721) returns (address) {
    (address owner, uint256 ownerTokenId, bool isNft) = directOwnerOf(
        tokenId
    );
    if (isNft) {
        owner = IERC7401(owner).ownerOf(ownerTokenId);
    }
    return owner;
}

function directOwnerOf(
    uint256 tokenId
) public view virtual returns (address, uint256, bool) {
    DirectOwner memory owner = _directOwners[tokenId];
    if (owner.ownerAddress == address(0)) revert ERC721InvalidTokenId();

    return (owner.ownerAddress, owner.tokenId, owner.tokenId != 0);
}

function burn(
    uint256 tokenId,
    uint256 maxChildrenBurns
) public virtual onlyApprovedOrDirectOwner(tokenId) returns (uint256) {
    return _burn(tokenId, maxChildrenBurns);
}

function _burn(
    uint256 tokenId,
    uint256 maxChildrenBurns
) internal virtual returns (uint256) {
    (address immediateOwner, uint256 parentId, ) = directOwnerOf(tokenId);
    address rootOwner = ownerOf(tokenId);

    _beforeTokenTransfer(immediateOwner, address(0), tokenId);
    _beforeNestedTokenTransfer(
        immediateOwner,
        address(0),
        parentId,
        0,
        tokenId,
        ""
    );

    _balances[immediateOwner] -= 1;
    _approve(address(0), tokenId);
    _cleanApprovals(tokenId);

    Child[] memory children = childrenOf(tokenId);

    delete _activeChildren[tokenId];
    delete _pendingChildren[tokenId];
    delete _tokenApprovals[tokenId][rootOwner];

    uint256 pendingRecursiveBurns;
    uint256 totalChildBurns;

    uint256 length = children.length; //gas savings
    for (uint256 i; i < length; ) {
        if (totalChildBurns >= maxChildrenBurns)
            revert MaxRecursiveBurnsReached(
                children[i].contractAddress,
                children[i].tokenId
            );
        delete _childIsInActive[children[i].contractAddress][
            children[i].tokenId
        ];
        unchecked {
            // At this point we know pendingRecursiveBurns must be at least 1
            pendingRecursiveBurns = maxChildrenBurns - totalChildBurns;
        }
        // We substract one to the next level to count for the token being burned, then add it again on returns
        // This is to allow the behavior of 0 recursive burns meaning only the current token is deleted.
        totalChildBurns +=
            IERC7401(children[i].contractAddress).burn(
                children[i].tokenId,
                pendingRecursiveBurns - 1
            ) +
            1;
        unchecked {
            ++i;
        }
    }
    // Can't remove before burning child since child will call back to get root owner
    delete _directOwners[tokenId];

    emit Transfer(immediateOwner, address(0), tokenId);
    emit NestTransfer(immediateOwner, address(0), parentId, 0, tokenId);

    _afterTokenTransfer(immediateOwner, address(0), tokenId);
    _afterNestedTokenTransfer(
        immediateOwner,
        address(0),
        parentId,
        0,
        tokenId,
        ""
    );

    return totalChildBurns;
}

function approve(address to, uint256 tokenId) public virtual {
    address owner = ownerOf(tokenId);
    if (to == owner) revert ERC721ApprovalToCurrentOwner();

    if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender()))
        revert ERC721ApproveCallerIsNotOwnerNorApprovedForAll();

    _approve(to, tokenId);
}

function getApproved(uint256 tokenId) public view virtual returns (address) {
    _requireMinted(tokenId);

    return _tokenApprovals[tokenId][ownerOf(tokenId)];
}

function setApprovalForAll(address operator, bool approved) public virtual {
    if (_msgSender() == operator) revert ERC721ApproveToCaller();
    _operatorApprovals[_msgSender()][operator] = approved;
    emit ApprovalForAll(_msgSender(), operator, approved);
}

function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
    return _operatorApprovals[owner][operator];
}

function _approve(address to, uint256 tokenId) internal virtual {
    address owner = ownerOf(tokenId);
    _tokenApprovals[tokenId][owner] = to;
    emit Approval(owner, to, tokenId);
}

function _updateOwnerAndClearApprovals(uint256 tokenId, uint256 destinationId, address to) internal {
    _directOwners[tokenId] = DirectOwner({
        ownerAddress: to,
        tokenId: destinationId
    });

    // 前の所有者からの承認情報をクリアします
    _approve(address(0), tokenId);
    _cleanApprovals(tokenId);
}

function _cleanApprovals(uint256 tokenId) internal virtual {}

function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
    address owner = ownerOf(tokenId);
    return (spender == owner ||
        isApprovedForAll(owner, spender) ||
        getApproved(tokenId) == spender);
}

function _isApprovedOrDirectOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
    (address owner, uint256 parentId, ) = directOwnerOf(tokenId);
    if (parentId != 0) {
        return (spender == owner);
    }
    return (spender == owner ||
        isApprovedForAll(owner, spender) ||
        getApproved(tokenId) == spender);
}

function _requireMinted(uint256 tokenId) internal view virtual {
    if (!_exists(tokenId)) revert ERC721InvalidTokenId();
}

function _exists(uint256 tokenId) internal view virtual returns (bool) {
    return _directOwners[tokenId].ownerAddress != address(0);
}

function _checkOnERC721Received(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
) private returns (bool) {
    if (to.isContract()) {
        try
            IERC721Receiver(to).onERC721Received(
                _msgSender(),
                from,
                tokenId,
                data
            )
        returns (bytes4 retval) {
            return retval == IERC721Receiver.onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == uint256(0)) {
                revert ERC721TransferToNonReceiverImplementer();
            } else {
                /// @solidity memory-safe-assembly
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    } else {
        return true;
    }
}

function addChild(
    uint256 parentId,
    uint256 childId,
    bytes memory data
) public virtual {
    _requireMinted(parentId);

    address childAddress = _msgSender();
    if (!childAddress.isContract()) revert IsNotContract();

    Child memory child = Child({
        contractAddress: childAddress,
        tokenId: childId
    });

    _beforeAddChild(parentId, childAddress, childId, data);

    uint256 length = pendingChildrenOf(parentId).length;

    if (length < 128) {
        _pendingChildren[parentId].push(child);
    } else {
        revert MaxPendingChildrenReached();
    }

    // Previous length matches the index for the new child
    emit ChildProposed(parentId, length, childAddress, childId);

    _afterAddChild(parentId, childAddress, childId, data);
}

function acceptChild(
    uint256 parentId,
    uint256 childIndex,
    address childAddress,
    uint256 childId
) public virtual onlyApprovedOrOwner(parentId) {
    _acceptChild(parentId, childIndex, childAddress, childId);
}

function _acceptChild(
    uint256 parentId,
    uint256 childIndex,
    address childAddress,
    uint256 childId
) internal virtual {
    Child memory child = pendingChildOf(parentId, childIndex);
    _checkExpectedChild(child, childAddress, childId);
    if (_childIsInActive[childAddress][childId] != 0)
        revert ChildAlreadyExists();

    _beforeAcceptChild(parentId, childIndex, childAddress, childId);

    // Remove from pending:
    _removeChildByIndex(_pendingChildren[parentId], childIndex);

    // Add to active:
    _activeChildren[parentId].push(child);
    _childIsInActive[childAddress][childId] = 1; // We use 1 as true

    emit ChildAccepted(parentId, childIndex, childAddress, childId);

    _afterAcceptChild(parentId, childIndex, childAddress, childId);
}

function rejectAllChildren(
    uint256 tokenId,
    uint256 maxRejections
) public virtual onlyApprovedOrOwner(tokenId) {
    _rejectAllChildren(tokenId, maxRejections);
}

function _rejectAllChildren(
    uint256 tokenId,
    uint256 maxRejections
) internal virtual {
    if (_pendingChildren[tokenId].length > maxRejections)
        revert UnexpectedNumberOfChildren();

    _beforeRejectAllChildren(tokenId);
    delete _pendingChildren[tokenId];
    emit AllChildrenRejected(tokenId);
    _afterRejectAllChildren(tokenId);
}

function transferChild(
    uint256 tokenId,
    address to,
    uint256 destinationId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes memory data
) public virtual onlyApprovedOrOwner(tokenId)

function transferChild(
    uint256 tokenId,
    address to,
    uint256 destinationId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes memory data
) public virtual onlyApprovedOrOwner(tokenId) {
    _transferChild(
        tokenId,
        to,
        destinationId,
        childIndex,
        childAddress,
        childId,
        isPending,
        data
    );
}

function _transferChild(
    uint256 tokenId,
    address to,
    uint256 destinationId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes memory data
) internal virtual {
    Child memory child;
    if (isPending) {
        child = pendingChildOf(tokenId, childIndex);
    } else {
        child = childOf(tokenId, childIndex);
    }
    _checkExpectedChild(child, childAddress, childId);

    _beforeTransferChild(
        tokenId,
        childIndex,
        childAddress,
        childId,
        isPending,
        data
    );

    if (isPending) {
        _removeChildByIndex(_pendingChildren[tokenId], childIndex);
    } else {
        delete _childIsInActive[childAddress][childId];
        _removeChildByIndex(_activeChildren[tokenId], childIndex);
    }

    if (to != address(0)) {
        if (destinationId == uint256(0)) {
            IERC721(childAddress).safeTransferFrom(
                address(this),
                to,
                childId,
                data
            );
       

 } else {
            // Destination is an NFT
            IERC7401(child.contractAddress).nestTransferFrom(
                address(this),
                to,
                child.tokenId,
                destinationId,
                data
            );
        }
    }

    emit ChildTransferred(
        tokenId,
        childIndex,
        childAddress,
        childId,
        isPending,
        to == address(0)
    );
    _afterTransferChild(
        tokenId,
        childIndex,
        childAddress,
        childId,
        isPending,
        data
    );
}

function _checkExpectedChild(
    Child memory child,
    address expectedAddress,
    uint256 expectedId
) private pure {
    if (
        expectedAddress != child.contractAddress ||
        expectedId != child.tokenId
    ) revert UnexpectedChildId();
}

function childrenOf(
    uint256 parentId
) public view virtual returns (Child[] memory) {
    Child[] memory children = _activeChildren[parentId];
    return children;
}

function pendingChildrenOf(
    uint256 parentId
) public view virtual returns (Child[] memory) {
    Child[] memory pendingChildren = _pendingChildren[parentId];
    return pendingChildren;
}

function childOf(
    uint256 parentId,
    uint256 index
) public view virtual returns (Child memory) {
    if (childrenOf(parentId).length <= index)
        revert ChildIndexOutOfRange();
    Child memory child = _activeChildren[parentId][index];
    return child;
}

function pendingChildOf(
    uint256 parentId,
    uint256 index
) public view virtual returns (Child memory) {
    if (pendingChildrenOf(parentId).length <= index)
        revert PendingChildIndexOutOfRange();
    Child memory child = _pendingChildren[parentId][index];
    return child;
}

/**
 * @notice トークンの転送前に呼び出されるフックです。これには鋳造（minting）および焼却（burning）も含まれます。
 * @dev 呼び出しの条件:
 *
 *  - `from` と `to` が両方ともゼロでない場合、`from` の `tokenId` は `to` に転送されます。
 *  - `from` がゼロの場合、`tokenId` は `to` に鋳造されます。
 *  - `to` がゼロの場合、`from` の `tokenId` は焼却されます。
 *  - `from` と `to` は同時にゼロになりません。
 *
 *  フックについて詳しくは、xref:ROOT:extending-contracts.adoc#using-hooks[フックの使用]を参照してください。
 * @param from トークンが転送されるアドレス
 * @param to トークンが転送されるアドレス
 * @param tokenId 転送されるトークンのID
 */
function _beforeTokenTransfer(
    address from,
    address to,
    uint256 tokenId
) internal virtual {}

function _afterTokenTransfer(
    address from,
    address to,
    uint256 tokenId
) internal virtual {}

function _beforeNestedTokenTransfer(
    address from,
    address to,
    uint256 fromTokenId,
    uint256 toTokenId,
    uint256 tokenId,
    bytes memory data
) internal virtual {}

function _afterNestedTokenTransfer(
    address from,
    address to,
    uint256 fromTokenId,
    uint256 toTokenId,
    uint256 tokenId,
    bytes memory data
) internal virtual {}

function _beforeAddChild(
    uint256 tokenId,
    address childAddress,
    uint256 childId,
    bytes memory data
) internal virtual {}

function _afterAddChild(
    uint256 tokenId,
    address childAddress,
    uint256 childId,
    bytes memory data
) internal virtual {}

function _beforeAcceptChild(
    uint256 parentId,
    uint256 childIndex,
    address childAddress,
    uint256 childId
) internal virtual {}

function _afterAcceptChild(
    uint256 parentId,
    uint256 childIndex,
    address childAddress,
    uint256 childId
) internal virtual {}

function _beforeTransferChild(
    uint256 tokenId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes memory data
) internal virtual {}

function _afterTransferChild(
    uint256 tokenId,
    uint256 childIndex,
    address childAddress,
    uint256 childId,
    bool isPending,
    bytes memory data
) internal virtual {}