Stacked NFTs - NFTs with quantity - A solution to minting large amount of same NFTs

[markopoloparadox]

Simple Summary

Stacked NFTs allow for light* minting unlimited** NFTs that contain the same data. Besides the light mint, operations like split stack, combine stack are also supported. On Marketplace you can either sell the whole stack (with all the items) or set the stack for sell and allow users to buy from 1 to 1000 NFTs from that stack per tx.

Terminology

In this discussion I will be using the following definition for "stack" (source: WoW):

A grouped number of the same items which take up only one... ...slot.

Here "same items" means NFTs that have the same NFTData.

Rest state: An NFT which is not rented, delegated, listed for sale,...

Motivation:

In video games it's common to see the same item being multiplied and stored inside a stack. This isn't only applicable to games, in the rest of the entertainment industry we can see the same behavior like for theaters or concert tickets. Since this behavior is quite common it would make sense for us to have the same or similar behavior available on our blockchain.

Currently to mint 1 million NFTs you would need to do 500 batched transactions (2k per batch) which would take at least 50 minutes to do it. You can get a similar effect with Stacked NFTs with just two transactions which takes 12 seconds to do it.

Implementation

Extending Basic NFT

Storage

One new storage will be created:

StackedNfts = Map<NFTId, u32>

Two existing storage will be updated:

struct NFTState {
	pub is_capsule: bool,
	pub listed_for_sale: bool,
	pub is_secret: bool,
	pub is_delegated: bool,
	pub is_soulbound: bool,
	pub is_stacked: bool,   // <- New
}

pub struct Collection
{
	pub owner: AccountId,
	pub offchain_data: U8BoundedVec<CollectionOffChainDataLimit>,
	pub nfts: BoundedVec<NFTId, CollectionSizeLimit>,
	pub limit: Option<u32>,
	pub is_closed: bool,
        pub reserved_nfts: u32  // <- New
}

Interface

The following interfaces(extrinsics) will be added:

fn convert_to_stack(nft_id: NFTId, quantity: u32)
fn split_stack(nft_id: NFTId, split_1: u32, split_2: u32)
fn combine_stacks(nft_id_1: NFTId, nft_id_2: NFTId)
fn set_stack_size(nft_id: NFTId, quantity: u32)

convert_to_stack

Descriptions: Creates a stack out of an existing NFT. The caller pays the full price for all those NFTs (example: quantity 100 means the user needs to pay 99 x NFT mint fee to treasury.)
Constraints:

• NFT needs to be created and owned by the caller
• NFT needs to be in a rest state
• NFT is not already a stack
• Quantity needs to be > 1
• if the NFT is in a collection, the length of the collection + quantity cannot be larger than collection limit.

split_stack

Descriptions: Splits a stack into two (stacked) NFTs. If one of the split stacks has the quantity 1, it will actually not become a stacked NFT instead it will be a normal one.
Constraints:

• NFT needs to be owned by the caller
• NFT needs to be in a rest state
• NFT needs to be stacked
• split_1 and split_2 cannot be less than 1

combine_stacks

Descriptions: Combines any two (stacked) NFTs into a stacked NFT. The nft_id_1 will become the combined NFT while the nft_id_2 will be destroyed. You can combine any stacked and non stacked NFTs as long as they are the same.
Constraints:

• NFT needs to be owned by the caller
• NFT needs to be in a rest state
• nft_id_1 and nft_id_2 needs to have the same NFTData.

set_stack_size

Descriptions: Increases or deceases the size of a existing stack. If increases then the caller pays for the additional NFTs.
Constraints:

• NFT needs to be created and owned by the caller
• NFT needs to be in a rest state
• Quantity needs to be > 1
• if the NFT is in a collection, the length of the collection + quantity cannot be larger than collection limit.

Extending Marketplace

Storage

One existing storage will be updated:

pub struct Sale
{
	pub account_id: AccountId,
	pub marketplace_id: MarketplaceId,
	pub price: Balance,
	pub commission_fee: Option<CompoundFee<Balance>>,
	pub stack_quantity: Option<(u32, u32)>,  // <- New Option<Quantity, Chunk Size>, 
}

Interface

The following interfaces(extrinsics) will be added:

fn list_stack(nft_id: NFTId, marketplace_id: MarketplaceId, chunk_size: Option<u32>,  price: Balance)
fn buy_stack(nft_id: NFTId, quantity: u32)

list_stack (Placeholder name)

Descriptions: It lists a stack to be bought in chunks. The chunk_size represents the maximum amount of NFTs that can be bought in one go. If set to None there is no limit. There is a hard limit that will be set to 1000.
Constraints:

• NFT needs to be owned by the caller
• NFT needs to be in a rest state
• NFT needs to be stacked

buy_stack (Placeholder name)

Descriptions: Buys quantity number of NFTs from one stack. If quantity is larger than 1 the user gets a stacked NFT.
Constraints:

• NFT cannot be owned by the caller
• The number of stacked NFTs needs to be larger than quantity.
• Quantitiy cannot be larger than chuck size.

Interaction with the rest of the system

The added Basic NFT extension doesn't have a impact on how other extensions (besides collections) and features work. You can normally list/auction an NFT that is stacked and the person who bought that NFT will get the whole stacked NFT. The list_stack interface here is only to provide a option to sell chunks of a stacked NFT instead of everything.

Additional Information

A stacked NFT with quantity 0 is automatically destroyed.
A stacked NFT with quantity 1 will automatically become a non-stacked NFT (unless the NFT is listed for sale)