Deprecation Notice
The Flow NFT Catalog is deprecated in favor of the Token List. Please update your references accordingly.
Composability Chronicles #1: How to build your Flow NFT for composability
Overview
NFT composability refers to the ability of different Non-Fungible Tokens (NFTs) to be combined, linked, and interact with each other in a meaningful way. This allows NFTs to be used as building blocks to create new and more complex NFTs, or to be integrated into various decentralized applications, marketplaces, games, and platforms.
In this guide, we will walk through the process of building a composable NFT contract. We will cover setting up the development environment, writing the contracts, supporting transactions and scripts, along with how to deploy the contract to testnet. By the end of this guide, you will have a solid understanding of how to build a composable NFT on Flow. This guide will assume that you have a beginner level understanding of cadence.
All of the resulting code from this guide is available here.
Preparation
Before we begin building our composable NFT, we need to set up the development environment.
- To start, download and install the Flow CLI here
- It is highly recommended to go through the basic NFT tutorial here. This is a more advanced one.
- Using git, clone the https://github.com/bshahid331/my-nft-project/tree/skeleton repository as a starting point.
- Navigate to the newly created my-nft-project folder, the my-nft-project folder with a text editor of your choice (i.e. VSCode)
The repo has multiple folder which will provide us with a starting point for all needed boilerplate to build a Flow NFT
/flow.json- Configuration file to help manage local, testnet, and mainnet flow deployments of contracts from the/cadencefolder/cadence/contracts- Smart contracts that can be deployed to the Flow chain/transactions- Transactions that can perform changes to data on the Flow blockchain/scripts- Scripts that can provide read-only access to data on the Flow blockchain
Standard Contracts
The starter code includes important standard contracts that we will use to build our NFT. Make sure you add them to your project in the contracts
The contracts are:
FungibleToken.cdc- This is a standard Flow smart contract that represents Fungible TokensNonFungibleToken.cdc- This is a standard Flow smart contract that represents NFTs. We will use this to implement our custom NFTMetadataViews.cdc- This contract is used to make our NFT interoperable. We will implement the metadata views specified in this contract so any Dapp can interact with our NFT!
Basic NFT Setup
Let’s start with a basic NFT
- Let’s create a new file called
MyFunNFT.cdc
import NonFungibleToken from "./NonFungibleToken.cdc"
pub contract MyFunNFT: NonFungibleToken {
pub event ContractInitialized()
pub event Withdraw(id: UInt64, from: Address?)
pub event Deposit(id: UInt64, to: Address?)
pub event Minted(id: UInt64, editionID: UInt64, serialNumber: UInt64)
pub event Burned(id: UInt64)
pub let CollectionStoragePath: StoragePath
pub let CollectionPublicPath: PublicPath
pub let CollectionPrivatePath: PrivatePath
/// The total number of NFTs that have been minted.
///
pub var totalSupply: UInt64
pub resource NFT: NonFungibleToken.INFT {
pub let id: UInt64
init(
) {
self.id = self.uuid
}
destroy() {
MyFunNFT.totalSupply = MyFunNFT.totalSupply - (1 as UInt64)
emit Burned(id: self.id)
}
}
pub resource interface MyFunNFTCollectionPublic {
pub fun deposit(token: @NonFungibleToken.NFT)
pub fun getIDs(): [UInt64]
pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT
pub fun borrowMyFunNFT(id: UInt64): &MyFunNFT.NFT? {
post {
(result == nil) || (result?.id == id):
"Cannot borrow MyFunNFT reference: The ID of the returned reference is incorrect"
}
}
}
pub resource Collection: MyFunNFTCollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic {
/// A dictionary of all NFTs in this collection indexed by ID.
///
pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT}
init () {
self.ownedNFTs <- {}
}
/// Remove an NFT from the collection and move it to the caller.
///
pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT {
let token <- self.ownedNFTs.remove(key: withdrawID)
?? panic("Requested NFT to withdraw does not exist in this collection")
emit Withdraw(id: token.id, from: self.owner?.address)
return <- token
}
/// Deposit an NFT into this collection.
///
pub fun deposit(token: @NonFungibleToken.NFT) {
let token <- token as! @MyFunNFT.NFT
let id: UInt64 = token.id
// add the new token to the dictionary which removes the old one
let oldToken <- self.ownedNFTs[id] <- token
emit Deposit(id: id, to: self.owner?.address)
destroy oldToken
}
/// Return an array of the NFT IDs in this collection.
///
pub fun getIDs(): [UInt64] {
return self.ownedNFTs.keys
}
/// Return a reference to an NFT in this collection.
///
/// This function panics if the NFT does not exist in this collection.
///
pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT {
return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)!
}
/// Return a reference to an NFT in this collection
/// typed as MyFunNFT.NFT.
///
/// This function returns nil if the NFT does not exist in this collection.
///
pub fun borrowMyFunNFT(id: UInt64): &MyFunNFT.NFT? {
if self.ownedNFTs[id] != nil {
let ref = (&self.ownedNFTs[id] as auth &NonFungibleToken.NFT?)!
return ref as! &MyFunNFT.NFT
}
return nil
}
destroy() {
destroy self.ownedNFTs
}
}
pub fun mintNFT(): @MyFunNFT.NFT {
let nft <- create MyFunNFT.NFT()
MyFunNFT.totalSupply = MyFunNFT.totalSupply + (1 as UInt64)
return <- nft
}
pub fun createEmptyCollection(): @NonFungibleToken.Collection {
return <- create Collection()
}
init() {
self.CollectionPublicPath = PublicPath(identifier: "MyFunNFT_Collection")!
self.CollectionStoragePath = StoragePath(identifier: "MyFunNFT_Collection")!
self.CollectionPrivatePath = PrivatePath(identifier: "MyFunNFT_Collection")!
self.totalSupply = 0
emit ContractInitialized()
}
}
This code implements a fundamental flow of Non-Fungible Tokens (NFTs) by extending the NonFungibleToken.INFT resource and a basic collection through MyFunNFTCollectionPublic. The program includes essential events that can be emitted, global variables that determine the storage paths of NFTs in a user's account, and a public mint function to create NFTs. It is worth noting that public minting is typically reserved for distributing free NFTs, while minting for profit requires an admin or the integration of a payment mechanism within the function.
Although this is commendable progress, the current NFT implementation lacks data. To remedy this, we can introduce customizable data fields for each NFT. For instance, in this use case, we aim to incorporate editions, each with a unique name, description, and serial number, much like the TopShot platform
Firstly, we will introduce two global variables at the top of the code, alongside totalSupply:
pub var totalEditions: UInt64
access(self) let editions: {UInt64: Edition}
We need to update the init() function for this contract. Add
self.totalEditions = 0
self.editions = {}
Should look like this
init() {
self.CollectionPublicPath = PublicPath(identifier: "MyFunNFT_Collection")!
self.CollectionStoragePath = StoragePath(identifier: "MyFunNFT_Collection")!
self.CollectionPrivatePath = PrivatePath(identifier: "MyFunNFT_Collection")!
self.totalSupply = 0
self.totalEditions = 0
self.editions = {}
emit ContractInitialized()
}
These variables will facilitate monitoring the overall count of editions and accessing a specific edition through its assigned identifier. The editionsdictionary will provide a means to extract particular information for each edition. Consequently, we will proceed to construct the Editionstruct that we refer to within our editionsobject.
pub struct Edition {
pub let id: UInt64
/// The number of NFTs minted in this edition.
///
/// This field is incremented each time a new NFT is minted.
///
pub var size: UInt64
/// The number of NFTs in this edition that have been burned.
///
/// This field is incremented each time an NFT is burned.
///
pub var burned: UInt64
pub fun supply(): UInt64 {
return self.size - self.burned
}
/// The metadata for this edition.
pub let metadata: Metadata
init(
id: UInt64,
metadata: Metadata
) {
self.id = id
self.metadata = metadata
self.size = 0
self.burned = 0
}
/// Increment the size of this edition.
///
access(contract) fun incrementSize() {
self.size = self.size + (1 as UInt64)
}
/// Increment the burn count for this edition.
///
access(contract) fun incrementBurned() {
self.burned = self.burned + (1 as UInt64)
}
}
This is a fundamental struct that we will employ to represent "Editions" within this NFT. It retains an id, the size, the burned count, and a bespoke Metadataobject defined below. Please include this struct in your code as well.
pub struct Metadata {
pub let name: String
pub let description: String
init(
name: String,
description: String
) {
self.name = name
self.description = description
}
}
To maintain simplicity, the Metadatain this instance consists solely of a name and a description. However, if necessary, you may include more complex data within this object
We will now proceed to modify the NFT resource to include additional fields that allow us to track which "edition" each NFT belongs to and its serial number. We will be storing this information in the NFT resource. Following are the steps to accomplish this:
Add the following fields below id in the NFT resource:
pub let editionID: UInt64
pub let serialNumber: UInt64
Update the init() function in the NFT resource:
init(
editionID: UInt64,
serialNumber: UInt64
) {
self.id = self.uuid
self.editionID = editionID
self.serialNumber = serialNumber
}
Update the mintNFT() function to adhere to the new init() and the Edition struct:
pub fun mintNFT(editionID: UInt64): @MyFunNFT.NFT {
let edition = MyFunNFT.editions[editionID]
?? panic("edition does not exist")
// Increase the edition size by one
edition.incrementSize()
let nft <- create MyFunNFT.NFT(editionID: editionID, serialNumber: edition.size)
emit Minted(id: nft.id, editionID: editionID, serialNumber: edition.size)
// Save the updated edition
MyFunNFT.editions[editionID] = edition
MyFunNFT.totalSupply = MyFunNFT.totalSupply + (1 as UInt64)
return <- nft
}
The updated mintNFT()function now receives an edition ID for the NFT to be minted. It validates the ID and creates the NFT by incrementing the serial number. It then updates the global variables to reflect the new size and returns the new NFT.
Excellent progress! We can now mint new NFTs for a specific edition. However, we need to enable the creation of new editions. To accomplish this, we will add function that allows anyone to create an edition (although in a real-world scenario, this would typically be a capability reserved for admin-level users). Please note that for the purposes of this example, we will make this function public.
pub fun createEdition(
name: String,
description: String,
): UInt64 {
let metadata = Metadata(
name: name,
description: description,
)
MyFunNFT.totalEditions = MyFunNFT.totalEditions + (1 as UInt64)
let edition = Edition(
id: MyFunNFT.totalEditions,
metadata: metadata
)
// Save the edition
MyFunNFT.editions[edition.id] = edition
emit EditionCreated(edition: edition)
return edition.id
}
pub fun getEdition(id: UInt64): Edition? {
return MyFunNFT.editions[id]
}
followed by adding the getEdition helper method.
Let’s also add the new event:
pub event ContractInitialized()
pub event Withdraw(id: UInt64, from: Address?)
pub event Deposit(id: UInt64, to: Address?)
pub event Minted(id: UInt64, editionID: UInt64, serialNumber: UInt64)
pub event Burned(id: UInt64)
pub event EditionCreated(edition: Edition)
Your NFT should look something like this:
import NonFungibleToken from "./NonFungibleToken.cdc"
pub contract MyFunNFT: NonFungibleToken {
pub event ContractInitialized()
pub event Withdraw(id: UInt64, from: Address?)
pub event Deposit(id: UInt64, to: Address?)
pub event Minted(id: UInt64, editionID: UInt64, serialNumber: UInt64)
pub event Burned(id: UInt64)
pub event EditionCreated(edition: Edition)
pub let CollectionStoragePath: StoragePath
pub let CollectionPublicPath: PublicPath
pub let CollectionPrivatePath: PrivatePath
/// The total number of NFTs that have been minted.
///
pub var totalSupply: UInt64
pub var totalEditions: UInt64
access(self) let editions: {UInt64: Edition}
pub struct Metadata {
pub let name: String
pub let description: String
init(
name: String,
description: String
) {
self.name = name
self.description = description
}
}
pub struct Edition {
pub let id: UInt64
/// The number of NFTs minted in this edition.
///
/// This field is incremented each time a new NFT is minted.
///
pub var size: UInt64
/// The number of NFTs in this edition that have been burned.
///
/// This field is incremented each time an NFT is burned.
///
pub var burned: UInt64
pub fun supply(): UInt64 {
return self.size - self.burned
}
/// The metadata for this edition.
pub let metadata: Metadata
init(
id: UInt64,
metadata: Metadata
) {
self.id = id
self.metadata = metadata
self.size = 0
self.burned = 0
}
/// Increment the size of this edition.
///
access(contract) fun incrementSize() {
self.size = self.size + (1 as UInt64)
}
/// Increment the burn count for this edition.
///
access(contract) fun incrementBurned() {
self.burned = self.burned + (1 as UInt64)
}
}
pub resource NFT: NonFungibleToken.INFT {
pub let id: UInt64
pub let editionID: UInt64
pub let serialNumber: UInt64
init(
editionID: UInt64,
serialNumber: UInt64
) {
self.id = self.uuid
self.editionID = editionID
self.serialNumber = serialNumber
}
destroy() {
MyFunNFT.totalSupply = MyFunNFT.totalSupply - (1 as UInt64)
emit Burned(id: self.id)
}
}
pub resource interface MyFunNFTCollectionPublic {
pub fun deposit(token: @NonFungibleToken.NFT)
pub fun getIDs(): [UInt64]
pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT
pub fun borrowMyFunNFT(id: UInt64): &MyFunNFT.NFT? {
post {
(result == nil) || (result?.id == id):
"Cannot borrow MyFunNFT reference: The ID of the returned reference is incorrect"
}
}
}
pub resource Collection: MyFunNFTCollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic {
/// A dictionary of all NFTs in this collection indexed by ID.
///
pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT}
init () {
self.ownedNFTs <- {}
}
/// Remove an NFT from the collection and move it to the caller.
///
pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT {
let token <- self.ownedNFTs.remove(key: withdrawID)
?? panic("Requested NFT to withdraw does not exist in this collection")
emit Withdraw(id: token.id, from: self.owner?.address)
return <- token
}
/// Deposit an NFT into this collection.
///
pub fun deposit(token: @NonFungibleToken.NFT) {
let token <- token as! @MyFunNFT.NFT
let id: UInt64 = token.id
// add the new token to the dictionary which removes the old one
let oldToken <- self.ownedNFTs[id] <- token
emit Deposit(id: id, to: self.owner?.address)
destroy oldToken
}
/// Return an array of the NFT IDs in this collection.
///
pub fun getIDs(): [UInt64] {
return self.ownedNFTs.keys
}
/// Return a reference to an NFT in this collection.
///
/// This function panics if the NFT does not exist in this collection.
///
pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT {
return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)!
}
/// Return a reference to an NFT in this collection
/// typed as MyFunNFT.NFT.
///
/// This function returns nil if the NFT does not exist in this collection.
///
pub fun borrowMyFunNFT(id: UInt64): &MyFunNFT.NFT? {
if self.ownedNFTs[id] != nil {
let ref = (&self.ownedNFTs[id] as auth &NonFungibleToken.NFT?)!
return ref as! &MyFunNFT.NFT
}
return nil
}
destroy() {
destroy self.ownedNFTs
}
}
pub fun createEdition(
name: String,
description: String,
): UInt64 {
let metadata = Metadata(
name: name,
description: description,
)
MyFunNFT.totalEditions = MyFunNFT.totalEditions + (1 as UInt64)
let edition = Edition(
id: MyFunNFT.totalEditions,
metadata: metadata
)
// Save the edition
MyFunNFT.editions[edition.id] = edition
emit EditionCreated(edition: edition)
return edition.id
}
pub fun mintNFT(editionID: UInt64): @MyFunNFT.NFT {
let edition = MyFunNFT.editions[editionID]
?? panic("edition does not exist")
// Increase the edition size by one
edition.incrementSize()
let nft <- create MyFunNFT.NFT(editionID: editionID, serialNumber: edition.size)
emit Minted(id: nft.id, editionID: editionID, serialNumber: edition.size)
// Save the updated edition
MyFunNFT.editions[editionID] = edition
MyFunNFT.totalSupply = MyFunNFT.totalSupply + (1 as UInt64)
return <- nft
}
pub fun createEmptyCollection(): @NonFungibleToken.Collection {
return <- create Collection()
}
init() {
self.CollectionPublicPath = PublicPath(identifier: "MyFunNFT_Collection")!
self.CollectionStoragePath = StoragePath(identifier: "MyFunNFT_Collection")!
self.CollectionPrivatePath = PrivatePath(identifier: "MyFunNFT_Collection")!
self.totalSupply = 0
self.totalEditions = 0
self.editions = {}
emit ContractInitialized()
}
}
Adding Transactions
Now that we have the contract we need to create transactions that can be called to call the functions createEdition and mintNFT. These transactions can be called by any wallet since the methods are public on the contract.
Create these in your transactions folder.
-
createEdition.cdcimport MyFunNFT from "../contracts/MyFunNFT.cdc" transaction( name: String, description: String, ) { prepare(signer: AuthAccount) { } execute { MyFunNFT.createEdition(name: name, description: description) } }This transaction takes in a name and description and creates a new edition with it.
-
mintNFT.cdcimport MyFunNFT from "../contracts/MyFunNFT.cdc" import MetadataViews from "../contracts/MetadataViews.cdc" import NonFungibleToken from "../contracts/NonFungibleToken.cdc" transaction( editionID: UInt64, ) { let MyFunNFTCollection: &MyFunNFT.Collection{MyFunNFT.MyFunNFTCollectionPublic,NonFungibleToken.CollectionPublic,NonFungibleToken.Receiver,MetadataViews.ResolverCollection} prepare(signer: AuthAccount) { if signer.borrow<&MyFunNFT.Collection>(from: MyFunNFT.CollectionStoragePath) == nil { // Create a new empty collection let collection <- MyFunNFT.createEmptyCollection() // save it to the account signer.save(<-collection, to: MyFunNFT.CollectionStoragePath) // create a public capability for the collection signer.link<&{NonFungibleToken.CollectionPublic, MyFunNFT.MyFunNFTCollectionPublic, MetadataViews.ResolverCollection}>( MyFunNFT.CollectionPublicPath, target: MyFunNFT.CollectionStoragePath ) } self.MyFunNFTCollection = signer.borrow<&MyFunNFT.Collection{MyFunNFT.MyFunNFTCollectionPublic,NonFungibleToken.CollectionPublic,NonFungibleToken.Receiver,MetadataViews.ResolverCollection}>(from: MyFunNFT.CollectionStoragePath)! } execute { let item <- MyFunNFT.mintNFT(editionID: editionID) self.MyFunNFTCollection.deposit(token: <-item) } }
This transaction verifies whether a MyFunNFT collection exists for the user by checking the presence of a setup. If no such collection is found, the transaction sets it up. Subsequently, the transaction mints a new NFT and deposits it in the user's collection.
Interoperability
We have successfully implemented a simple Edition NFT and created transactions to create editions and mint NFTs. However, in order for other applications to build on top of or interface with our NFT, they would need to know that our NFT contains a Metadataobject with a nameand descriptionfield. Additionally, it is important to consider how each app would keep track of the individual metadata and its structure for each NFT, especially given that different developers may choose to implement metadata in entirely different ways.
In Cadence, MetadataViewsserve as a standardized way of accessing NFT metadata, regardless of the specific metadata implementation used in the NFT resource. By providing a consistent interface for accessing metadata, MetadataViewsenable developers to build applications that can work with any NFT that uses a MetadataViews, regardless of how that metadata is structured.
By using MetadataViews, we can facilitate interoperability between different applications and services that use NFTs, and ensure that the metadata associated with our NFTs can be easily accessed and used by other developers.
Now let’s unlock interoperability for our NFT…
Let’s start off by importing the MetadataViews contract to the top
import MetadataViews from "./MetadataViews.cdc”
Now we need to have our NFT resource extend the MetadataViews.Resolver interface.
pub resource NFT: NonFungibleToken.INFT, MetadataViews.Resolver
Now we must implement getViews and resolveView. The function getViews tells anyone which views this NFT supports and resolveView takes in a view type and returns the view itself. Some common views are:
ExternalURL - A website / link for an NFT
NFT Collection Data - Data on how to setup this NFT collection in a users account
Display View - How to display this NFT on a website
Royalties View - Any royalties that should be adhered to for a marketplace transaction
NFT Collection Display View - How to display the NFT collection on a website
Let’s add the following getViews implementation to our NFT resource.
pub fun getViews(): [Type] {
let views = [
Type<MetadataViews.Display>(),
Type<MetadataViews.ExternalURL>(),
Type<MetadataViews.NFTCollectionDisplay>(),
Type<MetadataViews.NFTCollectionData>(),
Type<MetadataViews.Royalties>(),
Type<MetadataViews.Edition>(),
Type<MetadataViews.Serial>()
]
return views
}
These function helps inform what specific views this NFT supports. In the same NFT resource add the following method:
pub fun resolveView(_ view: Type): AnyStruct? {
let edition = self.getEdition()
switch view {
case Type<MetadataViews.Display>():
return self.resolveDisplay(edition.metadata)
case Type<MetadataViews.ExternalURL>():
return self.resolveExternalURL()
case Type<MetadataViews.NFTCollectionDisplay>():
return self.resolveNFTCollectionDisplay()
case Type<MetadataViews.NFTCollectionData>():
return self.resolveNFTCollectionData()
case Type<MetadataViews.Royalties>():
return self.resolveRoyalties()
case Type<MetadataViews.Edition>():
return self.resolveEditionView(serialNumber: self.serialNumber, size: edition.size)
case Type<MetadataViews.Serial>():
return self.resolveSerialView(serialNumber: self.serialNumber)
}
return nil
}
Now lets go over each individual helper function that you should add to your NFT resource
pub fun resolveDisplay(_ metadata: Metadata): MetadataViews.Display {
return MetadataViews.Display(
name: metadata.name,
description: metadata.description,
thumbnail: MetadataViews.HTTPFile(url: "https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/1200px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg"),
)
}
1. This creates a display view and takes in the edition data to populate the name and description. I included a dummy image but you would want to include a unique thumbnail
pub fun resolveExternalURL(): MetadataViews.ExternalURL {
let collectionURL = "www.flow-nft-catalog.com"
return MetadataViews.ExternalURL(collectionURL)
}
2. This is a link for the NFT. I’m putting in a placeholder site for now but this would be something for a specific NFT not an entire collection. So something like www.collection_site/nft_id
pub fun resolveNFTCollectionDisplay(): MetadataViews.NFTCollectionDisplay {
let media = MetadataViews.Media(
file: MetadataViews.HTTPFile(url: "https://assets-global.website-files.com/5f734f4dbd95382f4fdfa0ea/63ce603ae36f46f6bb67e51e_flow-logo.svg"),
mediaType: "image"
)
return MetadataViews.NFTCollectionDisplay(
name: "MyFunNFT",
description: "The open interopable NFT",
externalURL: MetadataViews.ExternalURL("www.flow-nft-catalog.com"),
squareImage: media,
bannerImage: media,
socials: {}
)
}
3. This is a view that indicates to apps on how to display information about the collection. The externalURL here would be the website for the entire collection. I have linked a temporary flow image but you could many image you want here.
pub fun resolveNFTCollectionData(): MetadataViews.NFTCollectionData {
return MetadataViews.NFTCollectionData(
storagePath: MyFunNFT.CollectionStoragePath,
publicPath: MyFunNFT.CollectionPublicPath,
providerPath: MyFunNFT.CollectionPrivatePath,
publicCollection: Type<&MyFunNFT.Collection{MyFunNFT.MyFunNFTCollectionPublic}>(),
publicLinkedType: Type<&MyFunNFT.Collection{MyFunNFT.MyFunNFTCollectionPublic, NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, MetadataViews.ResolverCollection}>(),
providerLinkedType: Type<&MyFunNFT.Collection{MyFunNFT.MyFunNFTCollectionPublic, NonFungibleToken.CollectionPublic, NonFungibleToken.Provider, MetadataViews.ResolverCollection}>(),
createEmptyCollectionFunction: (fun (): @NonFungibleToken.Collection {
return <-MyFunNFT.createEmptyCollection()
})
)
}
4. This is a view that allows any Flow Dapps to have the information needed to setup a collection in any users account to support this NFT.
pub fun resolveRoyalties(): MetadataViews.Royalties {
return MetadataViews.Royalties([])
}
5. For now we will skip Royalties but here you can specify which addresses should receive royalties and how much.
pub fun resolveEditionView(serialNumber: UInt64, size: UInt64): MetadataViews.Edition {
return MetadataViews.Edition(
name: "Edition",
number: serialNumber,
max: size
)
}
pub fun resolveSerialView(serialNumber: UInt64): MetadataViews.Serial {
return MetadataViews.Serial(serialNumber)
}
6. These are some extra views we can support since this NFT has editions and serial numbers. Not all NFTs need to support this but it’s nice to have for our case.
Lastly we need our Collection resource to support MetadataViews.ResolverCollection
pub resource Collection: MyFunNFTCollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection
You should see an error that you need to implement borrowViewResolver. This is a method a Dapp can use on the collection to borrow an NFT that inherits to the MetadataViews.Resolver interface so that resolveView that we implemented earlier can be called.
pub fun borrowViewResolver(id: UInt64): &AnyResource{MetadataViews.Resolver} {
let nft = (&self.ownedNFTs[id] as auth &NonFungibleToken.NFT?)!
let nftRef = nft as! &MyFunNFT.NFT
return nftRef as &AnyResource{MetadataViews.Resolver}
}
Now your NFT is interoperable!
Your final NFT contract should look something like this.
Deploying the Project
Creating a sample testnet account
We will need an account to deploy the contract with. To set one up visit: https://testnet-faucet.onflow.org/.
Run flow keys generate and paste your public key on the site. Keep your private key handy for the future. I just created the account 0x503b9841a6e501eb on testnet.
Configuration
Deploying this on testnet is simple. We need to populate our config file with the relevant contracts and there addresses as well as where we want to deploy any new contracts.
Copy and replace your flow.json with the following:
{
"contracts": {
"NonFungibleToken": {
"source": "./cadence/contracts/NonFungibleToken.cdc",
"aliases": {
"testnet": "0x631e88ae7f1d7c20",
"mainnet": "0x1d7e57aa55817448"
}
},
"MetadataViews": {
"source": "./cadence/contracts/MetadataViews.cdc",
"aliases": {
"testnet": "0x631e88ae7f1d7c20",
"mainnet": "0x1d7e57aa55817448"
}
},
"FungibleToken": {
"source": "./cadence/contracts/FungibleToken.cdc",
"aliases": {
"emulator": "0xee82856bf20e2aa6",
"testnet": "0x9a0766d93b6608b7",
"mainnet": "0xf233dcee88fe0abe"
}
},
"MyFunNFT": "./cadence/contracts/MyFunNFT.cdc"
},
"networks": {
"emulator": "127.0.0.1:3569",
"mainnet": "access.mainnet.nodes.onflow.org:9000",
"testnet": "access.devnet.nodes.onflow.org:9000"
},
"accounts": {
"emulator-account": {
"address": "f8d6e0586b0a20c7",
"key": "6d12eebfef9866c9b6fa92b97c6e705c26a1785b1e7944da701fc545a51d4673"
},
"testnet-account": {
"address": "0x503b9841a6e501eb",
"key": "$MYFUNNFT_TESTNET_PRIVATEKEY"
}
},
"deployments": {
"emulator": {
"emulator-account": [
"NonFungibleToken",
"MetadataViews",
"MyFunNFT"
]
},
"testnet": {
"testnet-account": ["MyFunNFT"]
}
}
}
This is a file that is meant to be pushed so we don’t want to expose our private keys. Luckily we can reference environment variables so use the following command to update the "$MYFUNNFT_TESTNET_PRIVATEKEY" environment variable with your newly created private key.
export MYFUNNFT_TESTNET_PRIVATEKEY=<YOUR_PRIVATE_KEY_HERE>
This is telling Flow where to find the contracts NonFungibleToken, MetadataViews, FungibleToken. For MyFunNFT it’s specifying where to deploy it, being testnet-account. Run flow project deploy --network=testnet and your contract should be deployed on testnet!
You can see mine here: https://flow-view-source.com/testnet/account/0x503b9841a6e501eb/contract/MyFunNFT.
Creating and minting an NFT
Let’s mint an NFT to an account. We will run the transactions from before. I’m using my testnet blocto wallet with the address: 0xf5e9719fa6bba61a. The newly minted NFT will go into this account.
Check out these links to see what I ran.
Adding the NFT collection to the Catalog
Now that we have minted some NFTs into an account and made our NFT interoperable let’s add it to the NFT catalog.
What is the Flow NFT Catalog?
The Flow NFT Catalog is a repository of NFT’s on Flow that adhere to the Metadata standard and implement at least the core views. The core views being
External URL
NFT Collection Data
NFT Collection Display
Display
Royalties
When proposing an NFT to the catalog, it will make sure you have implemented these views correctly. Once added your NFT will easily be discoverable and other ecosystem developers can feel confident that your NFT has implemented the core views and build on top of your NFT using the Metadata views we implemented earlier!
Now go to www.flow-nft-catalog.com and click “Add NFT Collection”
1. It starts off by asking for the NFT contract. This is where the contract is deployed so what is in your flow.json and what we created via the faucet.
2. Now we need to enter the storage path. In our NFT it is /storage/MyFunNFT_Collection as well as an account that holds the NFT. This is 0xf5e9719fa6bba61a for me.
3. Now you should screen that verifies that you have implemented the “core” nft views correctly and you can also see the actual data being returned from the chain.
In the last step you can submit your collection to the NFT catalog and voila, you have created an NFT on Flow that can easily be discovered and supported on any Dapp in the Flow ecosystem!
Conclusion
In this tutorial, we created a basic NFT that supports multiple editions and unlimited serials. Each edition has a name and description and each NFT has a unique serial belonging to a specific Edition. We then made our NFT interoperable by implementing MetadataViews. We minted an NFT and added our NFT collection to the catalog so it’s easily discoverable and ready to be built on top of!
Final version of the code.