How to Create an NFT Project on Flow

info

For Cadence 0.42 go to Legacy Docs

info

This guide is an in-depth tutorial on launching NFT contracts from scratch. To launch in 2 minutes using a tool check out Touchstone

What are NFTs

NFTs, or Non-Fungible Tokens, represent a unique digital asset verified using blockchain technology. Unlike cryptocurrencies such as Bitcoin, which are fungible and can be exchanged on a one-for-one basis, NFTs are distinct and cannot be exchanged on a like-for-like basis. This uniqueness and indivisibility make them ideal for representing rare and valuable items like art, collectibles, tickets and even real estate. Their blockchain-backed nature ensures the authenticity and ownership of these digital assets.

Setting Up a Project

To start creating an NFT on the Flow blockchain, you'll first need some tools and configurations in place.

Installing Flow CLI

The Flow CLI (Command Line Interface) provides a suite of tools that allow developers to interact seamlessly with the Flow blockchain.

If you haven't installed the Flow CLI yet and have Homebrew installed, you can run brew install flow-cli. If you don’t have Homebrew, please follow the installation guide here.

Initializing a New Project

💡 Note: Here is a link to the completed code if you want to skip ahead or reference as you follow along.

Once you have the Flow CLI installed, you can set up a new project using the flow setup command. This command initializes the necessary directory structure and a flow.json configuration file (a way to configure your project for contract sources, deployments, accounts, and more):

flow setup foobar-nft

Upon execution, the command will generate the following directory structure:

/cadence
    /contracts
    /scripts
    /transactions
    /tests
flow.json

Now, navigate into the project directory:

cd foobar-nft

To begin, let's create a contract file named FooBar for the FooBar token, which will be the focus of this tutorial. To do this, we can use the boilerplate generate command from the Flow CLI:

flow generate contract FooBar

This will create a new file at cadence/contracts/FooBar.cdc with the following contents:

access(all) contract FooBar {
    init() {}
}

Setting Up Our NFT on the Contract

Understanding Resources

On the Flow blockchain, "Resources" are a key feature of the Cadence programming language. They represent unique, non-duplicable assets, ensuring that they can only exist in one place at a time. This concept is crucial for representing NFTs on Flow, as it guarantees their uniqueness.

To begin, let's define a basic NFT resource. This resource requires an init method, which is invoked when the resource is instantiated:

access(all) contract FooBar {
    access(all) resource NFT {
        init() {}
    }
    init() {}
}

Every resource in Cadence has a unique identifier assigned to it. We can use it to set an ID for our NFT. Here's how you can do that:

access(all) contract FooBar {
    access(all) resource NFT {
        access(all) let id: UInt64
        init() {
            self.id = self.uuid
        }
    }
    init() {}
}

To control the creation of NFTs, it's essential to have a mechanism that restricts their minting. This ensures that not just anyone can create an NFT and inflate its supply. To achieve this, you can introduce an NFTMinter resource that contains a createNFT function:

access(all) contract FooBar {
    // ...[previous code]...
    access(all) resource NFTMinter {
        access(all) fun createNFT(): @NFT {
            return <-create NFT()
        }
        init() {}
    }
    init() {}
}

In this example, the NFTMinter resource will be stored on the contract account's storage. This means that only the contract account will have the ability to mint new NFTs. To set this up, add the following line to the contract's init function:

access(all) contract FooBar {
    // ...[previous code]...
    init() {
        self.totalSupply = 0
        self.account.save(<- create NFTMinter(), to: /storage/fooBarNFTMinter)
    }
}

Setting Up an NFT Collection

Storing individual NFTs directly in an account's storage can cause issues, especially if you want to store multiple NFTs. Instead, it's required to create a collection that can hold multiple NFTs. This collection can then be stored in the account's storage.

Start by creating a new resource named Collection. This resource will act as a container for your NFTs, storing them in a dictionary indexed by their IDs.

access(all) contract FooBar {
    // ...[NFT resource code]...
    access(all) resource Collection {
        access(all) var ownedNFTs: @{UInt64: NFT}
        init() {
            self.ownedNFTs <- {}
        }
    }
    // ...[NFTMinter code]...
}

Fitting the Flow NFT Standard

To ensure compatibility and interoperability within the Flow ecosystem, it's crucial that your NFT contract adheres to the Flow NFT standard. This standard defines the events, functions, resources, metadata and other elements that a contract should have. By following this standard, your NFTs will be compatible with various marketplaces, apps, and other services within the Flow ecosystem.

Applying the Standard

To start, you need to inform the Flow blockchain that your contract will implement the NonFungibleToken standard. Since it's a standard, there's no need for deployment. It's already available on the Emulator, Testnet, and Mainnet for the community's benefit.

Begin by importing the token standard into your contract and adding the correct interface conformances to FooBar, NFT, and Collection:

import "NonFungibleToken"
access(all) contract FooBar: NonFungibleToken {
    // ...contract code
    access(all) resource NFT: NonFungibleToken.NFT {
        // ...NFT code
    }
    access(all) resource Collection: NonFungibleToken.Collection {
        // ...Collection Code
    }
    // ...rest of the contract code
}

These interface conformances for NFT and Collection inherit from other interfaces provide important functionality and restrictions for your NFT and Collection types.

To allow accounts to create their own collections, add a function in the main contract that creates a new Collection and returns it. This function takes a nftType: Type argument that allows the caller to specify which type of Collection they want to create. Contracts that implement multiple NFT and/or Collection types can use this argument, but since your contract is only implementing one NFT and Collection type, it can ignore the argument. You'll also want to add a simpler one directly to the Collection definition so users can directly create a collection from an existing collection:

access(all) contract FooBar: NonFungibleToken {
    // ...other FooBar contract code
    access(all) resource Collection: NonFungibleToken.Collection {
        // ...other Collection code
        /// createEmptyCollection creates an empty Collection of the same type
        /// and returns it to the caller
        /// @return A an empty collection of the same type
        access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
            return <-FooBar.createEmptyCollection(nftType: Type<@FooBar.NFT>())
        }
    }
    // ...other FooBar contract code
    /// createEmptyCollection creates an empty Collection for the specified NFT type
    /// and returns it to the caller so that they can own NFTs
    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} {
        return <- create Collection()
    }
    // ...FooBar minter and init code
}

To manage the NFTs within a collection, you'll need functions to deposit and withdraw NFTs. Here's how you can add a deposit function:

access(all) resource Collection: NonFungibleToken.Collection {
    access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
    /// deposit takes a NFT and adds it to the collections dictionary
    /// and adds the ID to the id array
    access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
        let token <- token as! @FooBar.NFT
        let id = token.id
        // add the new token to the dictionary which removes the old one
        let oldToken <- self.ownedNFTs[token.id] <- token
        destroy oldToken
    }
    // ...[following code]...
}

Similarly, you can add a withdraw function to remove an NFT from the collection:

access(all) resource Collection: NonFungibleToken.Collection {
    // ...[deposit code]...
    /// withdraw removes an NFT from the collection and moves it to the caller
    access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
        let token <- self.ownedNFTs.remove(key: withdrawID)
            ?? panic("Could not withdraw an NFT with the provided ID from the collection")
        return <-token
    }
    // ...[createEmptyCollection code]...
}

As you can see, this function has an access(NonFungibleToken.Withdraw) access modifier. This is an example of entitlements in Cadence. Entitlements are a way for developers to restrict access to privileged fields and functions in a composite type like a resource when a reference is created for it. In this example, the withdraw() function is always accessible to code that controls the full Collection object, but if a reference is created for it, the withdraw() function can only be called if the reference is authorized by the owner with NonFungibleToken.Withdraw, which is a standard entitlement defined by the FungibleToken contract:

// Example of an authorized entitled reference to a NonFungibleToken.Collection
<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>

Entitlements are important to understand because they are what protects privileged functionality in your resource objects from being accessed by third-parties. It is recommended to read the entitlements documentation to understand how to use the feature properly.

References can be freely up-casted and down-casted in Cadence, so it is important for privileged functionality to be protected by an entitlement so that it can only be accessed if it is authorized.

Standard NFT Events

Many projects rely on events the signal when withdrawals or deposits happen. Luckily, the NonFungibleToken standard handles the definition and emission of events for projects, so there is no need for you to add any events to your implementation for withdraw and deposit.

Here are the FungibleToken event definitions:

    /// Event that is emitted when a token is withdrawn,
    /// indicating the type, id, uuid, the owner of the collection that it was withdrawn from,
    /// and the UUID of the resource it was withdrawn from, usually a collection.
    ///
    /// If the collection is not in an account's storage, `from` will be `nil`.
    ///
    access(all) event Withdrawn(type: String, id: UInt64, uuid: UInt64, from: Address?, providerUUID: UInt64)
    /// Event that emitted when a token is deposited to a collection.
    /// Indicates the type, id, uuid, the owner of the collection that it was deposited to,
    /// and the UUID of the collection it was deposited to
    ///
    /// If the collection is not in an account's storage, `from`, will be `nil`.
    ///
    access(all) event Deposited(type: String, id: UInt64, uuid: UInt64, to: Address?, collectionUUID: UInt64)

These events are emitted by the Collection interface in the NonFungibleToken contract whenever the relevant function is called on any implementation.

There is also a standard NonFungibleToken.Updated event that your contract can emit if the NFT is updated in any way. This is optional though, so no need to include support for it in your implementation.

To facilitate querying, you'll also want a function to retrieve important information from the collection, like what types it supports and all the NFT IDs within a collection:

access(all) resource Collection: NonFungibleToken.Collection {
    // ...[withdraw code]...
    access(all) fun getIDs(): [UInt64] {
        return self.ownedNFTs.keys
    }
    /// getSupportedNFTTypes returns a list of NFT types that this receiver accepts
    access(all) view fun getSupportedNFTTypes(): {Type: Bool} {
        let supportedTypes: {Type: Bool} = {}
        supportedTypes[Type<@FooBar.NFT>()] = true
        return supportedTypes
    }
    /// Returns whether or not the given type is accepted by the collection
    /// A collection that can accept any type should just return true by default
    access(all) view fun isSupportedNFTType(type: Type): Bool {
        return type == Type<@FooBar.NFT>()
    }
    // ...[createEmptyCollection code]...
}

Supporting NFT Metadata

The Non-Fungible Token standard also enforces that implementations provide functionality to return a set of standard views about the tokens via the ViewResolver and MetadataViews definitions. These provide developers with standard ways of representing metadata about a given token such as token symbols, images, royalties, editions, website links, and standard account paths and types that third-parties can access in a standard way. You can see the metadata views documentation for a more thorough guide using a NFT contract as an example.

For now, you can add this code to your contract to support the important metadata:

access(all) contract FooBar: NonFungibleToken {
    // ...other FooBar contract code
    access(all) resource NFT: NonFungibleToken.NFT {
        // ...other NFT code
        /// Gets a list of views specific to the individual NFT
        access(all) view fun getViews(): [Type] {
            return [
                Type<MetadataViews.Display>(),
                Type<MetadataViews.Editions>(),
                Type<MetadataViews.NFTCollectionData>(),
                Type<MetadataViews.NFTCollectionDisplay>(),
                Type<MetadataViews.Serial>(),
            ]
        }
        /// Resolves a view for this specific NFT
        access(all) fun resolveView(_ view: Type): AnyStruct? {
            switch view {
                case Type<MetadataViews.Display>():
                    return MetadataViews.Display(
                        name: "FooBar Example Token",
                        description: "An Example NFT Contract from the Flow NFT Guide",
                        thumbnail: MetadataViews.HTTPFile(
                            url: "Fill this in with a URL to a thumbnail of the NFT"
                        )
                    )
                case Type<MetadataViews.Editions>():
                    // There is no max number of NFTs that can be minted from this contract
                    // so the max edition field value is set to nil
                    let editionInfo = MetadataViews.Edition(name: "FooBar Edition", number: self.id, max: nil)
                    let editionList: [MetadataViews.Edition] = [editionInfo]
                    return MetadataViews.Editions(
                        editionList
                    )
                case Type<MetadataViews.Serial>():
                    return MetadataViews.Serial(
                        self.id
                    )
                case Type<MetadataViews.NFTCollectionData>():
                    return FooBar.resolveContractView(resourceType: Type<@FooBar.NFT>(), viewType: Type<MetadataViews.NFTCollectionData>())
                case Type<MetadataViews.NFTCollectionDisplay>():
                    return FooBar.resolveContractView(resourceType: Type<@FooBar.NFT>(), viewType: Type<MetadataViews.NFTCollectionDisplay>())
            }
            return nil
        }
    }
    access(all) resource Collection: NonFungibleToken.Vault {
        // ...[getIDs code]...
        /// Allows a caller to borrow a reference to a specific NFT
        /// so that they can get the metadata views for the specific NFT
        access(all) fun borrowNFT(id: UInt64): &NonFungibleToken.NFT {
            return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)!
        }
        // ...[rest of code]...
    }
    /// Gets a list of views for all the NFTs defined by this contract
    access(all) view fun getContractViews(resourceType: Type?): [Type] {
        return [
            Type<MetadataViews.NFTCollectionData>(),
            Type<MetadataViews.NFTCollectionDisplay>(),
        ]
    }
    /// Resolves a view that applies to all the NFTs defined by this contract
    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
        switch viewType {
            case Type<MetadataViews.NFTCollectionData>():
                let collectionData = MetadataViews.NFTCollectionData(
                    storagePath: self.CollectionStoragePath,
                    publicPath: self.CollectionPublicPath,
                    publicCollection: Type<&FooBar.Collection>(),
                    publicLinkedType: Type<&FooBar.Collection>(),
                    createEmptyCollectionFunction: (fun(): @{NonFungibleToken.Collection} {
                        return <-FooBar.createEmptyCollection(nftType: Type<@FooBar.NFT>())
                    })
                )
                return collectionData
            case Type<MetadataViews.NFTCollectionDisplay>():
                let media = MetadataViews.Media(
                    file: MetadataViews.HTTPFile(
                        url: "Add your own SVG+XML link here"
                    ),
                    mediaType: "image/svg+xml"
                )
                return MetadataViews.NFTCollectionDisplay(
                    name: "The FooBar Example Collection",
                    description: "This collection is used as an example to help you develop your next Flow NFT.",
                    externalURL: MetadataViews.ExternalURL("Add your own link here"),
                    squareImage: media,
                    bannerImage: media,
                    socials: {
                        "twitter": MetadataViews.ExternalURL("Add a link to your project's twitter")
                    }
                )
        }
        return nil
    }
}

If you ever plan on making your NFTs more complex, you should look into adding views for Edition, EVMBridgedMetadata, Traits, and Royalties. These views make it much easier for third-party sites like marketplaces and NFT information aggregators to clearly display information about your projects on their apps and websites and are critical for every project to include if we want to have a vibrant and interoperable ecosystem.

Deploying the Contract

With your contract ready, it's time to deploy it. First, add the FooBar contract to the flow.json configuration file:

flow config add contract

When prompted, enter the following name and location (press Enter to skip alias questions):

Enter name: FooBar
Enter contract file location: cadence/contracts/FooBar.cdc

Next, configure the deployment settings by running the following command:

flow config add deployment

Choose the emulator for the network and emulator-account for the account to deploy to. Then, select the FooBar contract (you may need to scroll down). This will update your flow.json configuration. After that, you can select No when asked to deploy another contract.

To start the Flow emulator, run (you may need to approve a prompt to allow connection the first time):

flow emulator start

In a separate terminal or command prompt, deploy the contract:

flow project deploy

You’ll then see a message that says All contracts deployed successfully.

Creating an NFTCollection

To manage multiple NFTs, you'll need an NFT collection. Start by creating a transaction file for this purpose (we can use the generate command again):

flow generate transaction setup_foobar_collection

This creates a transaction file at cadence/transactions/setup_foobar_collection.cdc.

Transactions, on the other hand, are pieces of Cadence code that can mutate the state of the blockchain. Transactions need to be signed by one or more accounts, and they can have multiple phases, represented by different blocks of code.

In this file, import the necessary contracts and define a transaction to create a new collection, storing it in the account's storage. Additionally, the transaction creates a capability that allows others to get a public reference to the collection to read from its methods.

This capability ensures secure, restricted access to specific functionalities or information within a resource.

import "FooBar"
import "NonFungibleToken"
transaction {
    prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) {
        
        // Return early if the account already has a collection
        if signer.storage.borrow<&FooBar.Collection>(from: FooBar.CollectionStoragePath) != nil {
            return
        }
        // Create a new empty collection
        let collection <- FooBar.createEmptyCollection(nftType: Type<@FooBar.NFT>())
        // save it to the account
        signer.storage.save(<-collection, to: FooBar.CollectionStoragePath)
        let collectionCap = signer.capabilities.storage.issue<&FooBar.Collection>(FooBar.CollectionStoragePath)
        signer.capabilities.publish(collectionCap, at: FooBar.CollectionPublicPath)
    }
}

There are also examples of generic transactions that you can use to setup an account for ANY non-fungible token using metadata views! You should check those out and try to use generic transactions whenever it is possible.

To store this new NFT collection, create a new account:

flow accounts create

Name it test-acct and select emulator as the network. Then, using the Flow CLI, run the transaction:

flow transactions send cadence/transactions/setup_foobar_collection.cdc --signer test-acct --network emulator

Congratulations! You've successfully created an NFT collection for the test-acct.

Get an Account's NFTs

To retrieve the NFTs associated with an account, you'll need a script. Scripts are read-only operations that allow you to query the blockchain. They don't modify the blockchain's state, and therefore, they don't require gas fees or signatures (read more about scripts here).

Start by creating a script file using the generate command again:

flow generate script get_fooBar_ids

In this script, import the necessary contracts and define a function that retrieves the NFT IDs associated with a given account:

import "NonFungibleToken"
import "FooBar"
access(all) fun main(address: Address): [UInt64] {
    let account = getAccount(address)
    let collectionRef = account.capabilities.borrow<&{NonFungibleToken.Collection}>(
            FooBar.CollectionPublicPath
        ) ?? panic("Could not borrow capability from collection at specified path")
    return collectionRef.getIDs()
}

To check the NFTs associated with the test-acct, run the script (note: replace 0x123 with the address for test-acct from flow.json):

flow scripts execute cadence/scripts/get_fooBar_ids.cdc 0x123

Since you haven't added any NFTs to the collection yet, the result will be an empty array.

Minting and Depositing an NFT to a Collection

To mint and deposit an NFT into a collection, create a new transaction file:

flow generate transaction mint_fooBar_nft

In this file, define a transaction that takes a recipient's address as an argument. This transaction will borrow the minting capability from the contract account, borrow the recipient's collection capability, create a new NFT using the minter, and deposit it into the recipient's collection:

/// This script uses the NFTMinter resource to mint a new NFT
/// It must be run with the account that has the minter resource
/// stored in /storage/NFTMinter
///
/// The royalty arguments indicies must be aligned
import "NonFungibleToken"
import "FooBar"
transaction(
    recipient: Address
) {
    /// local variable for storing the minter reference
    let minter: &ExampleNFT.NFTMinter
    /// Reference to the receiver's collection
    let recipientCollectionRef: &{NonFungibleToken.Receiver}
    prepare(signer: auth(BorrowValue) &Account) {
        
        // borrow a reference to the NFTMinter resource in storage
        self.minter = signer.storage.borrow<&ExampleNFT.NFTMinter>(from: FooBar.MinterStoragePath)
            ?? panic("Account does not store an object at the specified path")
        // Borrow the recipient's public NFT collection reference
        self.recipientCollectionRef = getAccount(recipient).capabilities.borrow<&{NonFungibleToken.Receiver}>(
                FooBar.CollectionPublicPath
            ) ?? panic("Could not get receiver reference to the NFT Collection")
    }
    execute {
        // Mint the NFT and deposit it to the recipient's collection
        let mintedNFT <- self.minter.mintNFT()
        self.recipientCollectionRef.deposit(token: <-mintedNFT)
    }
}

To run this transaction, use the Flow CLI. Remember, the contract account (which has the minting resource) should be the one signing the transaction. Pass the test account's address (from the flow.json file) as the recipient argument (note: replace 0x123 with the address for test-acct from flow.json):

flow transactions send cadence/transactions/mint_fooBar_nft.cdc 0x123 --signer emulator-account --network emulator

After executing the transaction, you can run the earlier script to verify that the NFT was added to the test-acct's collection (remember to replace 0x123):

flow scripts execute cadence/scripts/get_fooBar_ids.cdc 0x123

You should now see a value in the test-acct's collection array!

Transferring an NFT to Another Account

To transfer an NFT to another account, create a new transaction file using generate:

flow generate transaction transfer_fooBar_nft

In this file, define a transaction that takes a recipient's address and the ID of the NFT you want to transfer as arguments. This transaction will borrow the sender's collection, get the recipient's capability, withdraw the NFT from the sender's collection, and deposit it into the recipient's collection:

import "FooBar"
import "NonFungibleToken"
transaction(recipient: Address, withdrawID: UInt64) {
    /// Reference to the withdrawer's collection
    let withdrawRef: auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}
    /// Reference of the collection to deposit the NFT to
    let receiverRef: &{NonFungibleToken.Receiver}
    prepare(signer: auth(BorrowValue) &Account) {
        // borrow a reference to the signer's NFT collection
        self.withdrawRef = signer.storage.borrow<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>(
                from: FooBar.CollectionStoragePath
            ) ?? panic("Account does not store an object at the specified path")
        // get the recipients public account object
        let recipient = getAccount(recipient)
        // borrow a public reference to the receivers collection
        let receiverCap = recipient.capabilities.get<&{NonFungibleToken.Receiver}>(FooBar.CollectionPublicPath)
        self.receiverRef = receiverCap.borrow()
            ?? panic("Could not borrow reference to the recipient's receiver")
    }
    execute {
        let nft <- self.withdrawRef.withdraw(withdrawID: withdrawID)
        self.receiverRef.deposit(token: <-nft)
    }
}

To transfer the NFT, first create a new account:

flow accounts create

Name it test-acct-2 and select Emulator as the network. Next, create a collection for this new account:

flow transactions send cadence/transactions/setup_foobar_collection.cdc --signer test-acct-2 --network emulator

Now, run the transaction to transfer the NFT from test-acct to test-acct-2 using the addresses from the flow.json file (replace 0x124 with test-acct-2's address. Also note that 0 is the id of the NFT we'll be transferring):

flow transactions send cadence/transactions/transfer_fooBar_nft.cdc 0x124 0 --signer test-acct --network emulator

To verify the transfer, you can run the earlier script for test-acct-2 (replace 0x124):

flow scripts execute cadence/scripts/get_fooBar_ids.cdc 0x123

The transfer transaction also has a generic version that developers are encouraged to use!

Congrats, you did it! You’re now ready to launch the next fun NFT project on Flow.

Explore an example NFT repository
Dive into the details of the NFT Standard
For a deeper dive into MetadataViews, consult the introduction guide or the FLIP that introduced this feature.
Use a no code tool for creating NFT projects on Flow

What are NFTs​

Setting Up a Project​

Installing Flow CLI​

Initializing a New Project​

Setting Up Our NFT on the Contract​

Understanding Resources​

Setting Up an NFT Collection​

Fitting the Flow NFT Standard​

Applying the Standard​

Standard NFT Events​

Supporting NFT Metadata​

Deploying the Contract​

Creating an NFTCollection​

Get an Account's NFTs​

Minting and Depositing an NFT to a Collection​

Transferring an NFT to Another Account​

More​