---
eip: 5606
title: Multiverse NFTs
description: A universal representation of multiple related NFTs as a single digital asset across various platforms
author: Gaurang Torvekar (@gaurangtorvekar), Khemraj Adhawade (@akhemraj), Nikhil Asrani (@nikhilasrani)
discussions-to: https://ethereum-magicians.org/t/eip-5606-multiverse-nfts-for-digital-asset-interoperability/10698
status: Final
type: Standards Track
category: ERC
created: 2022-09-06
requires: 721, 1155
---

## Abstract

This specification defines a minimal interface to create a multiverse NFT standard for digital assets such as wearables and in-game items that, in turn, index the delegate NFTs on each platform where this asset exists. These platforms could be metaverses, play-to-earn games or NFT marketplaces. This proposal depends on and extends [ERC-721](./eip-721.md) and [ERC-1155](./eip-1155.md). The standard also allows for the ‘bundling’ and ‘unbundling’ of these delegate NFTs within the multiverse NFT so holders can trade them individually or as a bundle.

## Motivation

Several metaverses and blockchain games ("platforms") exist that use NFT standards such as ERC-721 and ERC-1155 for creating in-universe assets like avatar wearables, in-game items including weapons, shields, potions and much more. The biggest shortcoming while using these standards is that there is no interoperability between these platforms. As a publisher, you must publish the same digital asset (for example, a shirt) on various platforms as separate ERC-721 or ERC-1155 tokens. Moreover, there is no relationship between these, although they represent the same digital asset in reality. Hence, it is very difficult to prove the scarcity of these items on-chain.

Since their inception, NFTs were meant to be interoperable and prove the scarcity of digital assets. Although NFTs can arguably prove the scarcity of items, the interoperability aspect hasn’t been addressed yet. Creating a multiverse NFT standard that allows for indexing and ownership of a digital asset across various platforms would be the first step towards interoperability and true ownership across platforms.

In the web3 ecosystem, NFTs have evolved to represent multiple types of unique and non-fungible assets. One type of asset includes a set of NFTs related to one another. For instance, if a brand releases a new sneaker across various metaverses, it would be minted as a separate NFT on each platform. However, it is, in reality, the same sneaker.
There is a need to represent the relationship and transferability of these types of NFTs as metaverses and blockchain games gain more mainstream adoption. The ecosystem needs a better framework to address this issue rather than relying on the application level. This framework should define the relationship between these assets and the nature of their association. There is more value in the combined recognition, use and transferability of these individual NFTs as a bundle rather than their selves.

## Specification

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119.

A multiverse NFT contract represents a digital asset across multiple platforms. This contract can own one or more delegate NFT tokens of the digital asset on the various platforms through bundling or unbundling.

```
/**
* @dev Interface of the Multiverse NFT standard as defined in the EIP.
*/
interface IMultiverseNFT {

   /**
    * @dev struct to store delegate token details
    *
    */
   struct DelegateData {
       address contractAddress;
       uint256 tokenId;
       uint256 quantity;
   }

   /**
    * @dev Emitted when one or more new delegate NFTs are added to a Multiverse NFT
    */
   event Bundled(uint256 multiverseTokenID, DelegateData[] delegateData, address ownerAddress);


   /**
    * @dev Emitted when one or more delegate NFTs are removed from a Multiverse NFT
    */
   event Unbundled(uint256 multiverseTokenID, DelegateData[] delegateData);

   /**
    * @dev Accepts the tokenId of the Multiverse NFT and returns an array of delegate token data
    */
   function delegateTokens(uint256 multiverseTokenID) external view returns (DelegateData[] memory);

   /**
    * @dev Removes one or more delegate NFTs from a Multiverse NFT
    * This function accepts the delegate NFT details and transfers those NFTs out of the Multiverse NFT contract to the owner's wallet
    */
   function unbundle(DelegateData[] memory delegateData, uint256 multiverseTokenID) external;

   /**
    * @dev Adds one or more delegate NFTs to a Multiverse NFT
    * This function accepts the delegate NFT details and transfers those NFTs to the Multiverse NFT contract
    * Need to ensure that approval is given to this Multiverse NFT contract for the delegate NFTs so that they can be transferred programmatically
    */
   function bundle(DelegateData[] memory delegateData, uint256 multiverseTokenID) external;

   /**
    * @dev Initialises a new bundle, mints a Multiverse NFT and assigns it to msg.sender
    * Returns the token ID of a new Multiverse NFT
    * Note - When a new Multiverse NFT is initialised, it is empty; it does not contain any delegate NFTs
    */
   function initBundle(DelegateData[] memory delegateData) external;
}
```

Any dapp implementing this standard would initialise a bundle by calling the function `initBundle`. This mints a new multiverse NFT and assigns it to msg.sender. While creating a bundle, the delegate token contract addresses and the token IDs are set during the initialisation and cannot be changed after that. This avoids unintended edge cases where non-related NFTs could be bundled together by mistake.

Once a bundle is initialised, the delegate NFT tokens can then be transferred to this Multiverse NFT contract by calling the function `bundle` and passing the token ID of the multiverse NFT. It is essential for a dapp to get the delegate NFTs ‘approved’ from the owner to this Multiverse NFT contract before calling the bundle function. After that, the Multiverse NFT owns one or more versions of this digital asset across the various platforms.

If the owner of the multiverse NFT wants to sell or use the individual delegate NFTs across any of the platforms, they can do so by calling the function `unbundle`. This function transfers the particular delegate NFT token(s) to msg.sender (only if `msg.sender` is the owner of the multiverse NFT).

## Rationale

The `delegateData` struct contains information about the delegate NFT tokens on each platform. It contains variables such as `contractAddress`, `tokenId`, `quantity` to differentiate the NFTs. These NFTs could be following either the ERC-721 standard or the ERC-1155 standard.

The `bundle` and `unbundle` functions accept an array of DelegateData struct because of the need to cater to partial bundling and unbundling. For instance, a user could initialise a bundle with three delegate NFTs, but they should be able to bundle and unbundle less than three at any time. They can never bundle or unbundle more than three. They also need the individual token IDs of the delegate NFTs to bundle and unbundle selectively.

## Backwards Compatibility

This standard is fully compatible with ERC-721 and ERC-1155. Third-party applications that don’t support this EIP will still be able to use the original NFT standards without any problems.

## Reference Implementation

[MultiverseNFT.sol](../assets/eip-5606/contracts/MultiverseNFT.sol)

## Security Considerations

The bundle function involves calling an external contract(s). So reentrancy prevention measures should be applied while implementing this function.

## Copyright

Copyright and related rights waived via [CC0](../LICENSE.md).
