Open IP Protocol

This protocol is also known as ERC721X, which extends the ERC721 standard to allow users to remix multiple existing NFTs and create a new NFT derivative work, while their relationships can be traced on the blockchain. It contains three core modules, remix module, network module, and license module.

Remix Module

This module extends ERC-721 standard and enables users to create a new NFT by remixing multiple existing NFTs, whether they’re ERC-721 or ERC-1155.

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.10;

interface IERC721X {
    // Events

    /// @dev Emits when a combo is minted.
    /// @param owner The owner address of the newly minted combo
    /// @param comboId The newly minted combo identifier
    event ComboMinted(address indexed owner, uint256 indexed comboId);

    // Structs

    /// @param tokenAddress The NFT's collection address
    /// @param tokenId The NFT identifier
    struct Token {
        address tokenAddress;
        uint256 tokenId;
    }

    /// @param amount The number of NFTs used
    /// @param licenseId Which license to be used to verify this component
    struct Component {
        Token token;
        uint256 amount;
        uint256 licenseId;
    }

    // Functions

    /// @dev Mints a NFT by remixing multiple existing NFTs.
    /// @param components The NFTs remixed to mint a combo
    /// @param hash The hash representing the algorithm about how to generate the combo's metadata when remixing multiple existing NFTs.
    function mint(
        Component[] calldata components,
        string calldata hash
    ) external;

    /// @dev Retrieve a combo's components.
    function getComponents(
        uint256 comboId
    ) external view returns (Component[] memory);
}

Depending on the different NFT derivative works, the parameters required in the mint function of the respective remix module vary.

In the NFT Derivatives section, we will provide examples of how to create NFT derivative works through 1Combo.

Network Module

This module follows the singleton pattern and is used to track all relationships between the original NFTs and their NFT derivative works.

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.10;

import "./IERC721X.sol";

interface INFTNetIndexer {
    /// @dev Verify if the `child` was created by remixing the `parent` with other NFTs.
    /// @param parent Any NFT
    /// @param child Any NFT
    function isParent(
        IERC721X.Token calldata parent,
        IERC721X.Token calldata child
    ) external view returns (bool);

    /// @dev Verify if `a` and `b` have common `parent`s
    /// @param a Any NFT
    /// @param b Any NFT
    function isSibling(
        IERC721X.Token calldata a,
        IERC721X.Token calldata b
    ) external view returns (bool, IERC721X.Token[] memory commonParents);

    /// @dev Return all parents of a `token`
    /// @param token Any NFT
    /// @return parents All NFTs used to mint the `token`
    function getParents(
        IERC721X.Token calldata token
    ) external view returns (IERC721X.Token[] memory parents);
}

Whenever a Combo is created, the network module will be notified to record the newly generated network relationship, making it public and immutable for other applications.

In the NFT Network section, we will explain the different types of network relationships.

License Module

By default, users can only remix multiple NFTs they own to create new NFT derivative works. This module enables NFT holders to grant others permission to use their NFTs in the remixing process.

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.10;

import "./IERC721X.sol";

interface ILicense {
    /// @dev Verify the permission when minting a combo
    /// @param user The minter
    /// @param combo The new NFT to be minted by remixing multiple existing NFTs
    /// @return components The multiple existing NFTs used to mint the new combo
    function verify(
        address user,
        IERC721X.Token calldata combo,
        IERC721X.Component[] calldata components
    ) external returns (bool);
}

Depending on the specific NFT licensing method, the verify function of the respective license module is triggered to ensure the minter owns the necessary permissions to create the new NFT derivative work.

In the NFT License section, we will introduce several common licensing methods.