Cointime

  • BTC $17223.31 -0.06 %
  • ETH $1281.78 -0.12 %
  • BCH $111.70 -0.18 %
  • SOL $13.66 -0.15 %
  • XRP $0.39 -0.30 %
  • BNB $289.70 -0.07 %

How To Make Your Own NFTs On Flow

TribalScale Inc.· 8 min read

Written by: Nicholas Cantone, Agile Software Engineer, TribalScale

With blockchain technologies gaining immense popularity in recent years, it’s likely you’ve heard the buzz about non fungible tokens, or NFTs. Unfortunately, the inner workings of NFTs seem to be hidden behind a veil of complex blockchain concepts filled with technical jargon. Luckily for you, by the end of this blog post you will have gained a much deeper understanding of how these NFTs are made.

Today, we will be diving into NFTs on the Flow blockchain. If you aren’t familiar with blockchain technologies here is a good article by the verge to get you started. In brief, Flow was created in 2020 by Dapper Labs to meet their own growing demands for an efficient platform to host their immensely popular blockchain-based game, CryptoKitties. The language we use to interact with the Flow blockchain is called Cadence. The following section of this blog will explain key cadence concepts and the final portion will bring all those concepts together and show you how to make your very own NFT from scratch.

Cadence Concepts

Resources

Cadence is a resource-oriented programming language meaning that resources play a huge part in any Flow project. But what are they and why are they so great?

Well… resources are a type in cadence, but you can think of them as a highly secure and unique container for information (similarly to objects in javascript or structures in C). These resources have fields or functions associated with them, like in the code example below:

What makes resources so secure is the restrictions that are placed on them. (if you don’t believe me, check out the docs) “[Resources] can only exist in one location at a time and must be used exactly once”, therefore, resources are unique (kind of like NFTs) and can’t ever be created and unused or go out of scope and be lost forever.

The way we use resources is by either moving them, or destroying them. You can see how these restrictions are so useful in the context of NFTs. For instance, if I create an NFT resource, I can’t lose track of it. I have to transfer it into another user’s account, save it into mine, or explicitly destroy it. Here is a small code excerpt that highlights the creation and moving of resources in a function:

Smart Contracts

Moving on to one of the most important tools in any blockchain developers tool shed, smart contracts. They’re essentially like recipes. Much like recipes they are divided into their state (list of ingredients) and logic (cooking steps). The state of the contract lives in the blockchain and can be thought of as the attributes of our contract. The state of our contract will also hold any type definitions (such as resources). The logic portion of the contract consists of functions which simply tell you how to view or modify the state.

If you’re wondering how you can deploy your very own contract to the Flow blockchain, the first step would be to create an account.

Your account is basically your little storage allocation of the blockchain. In your account, you can store all your contracts along with any other resource, in the final section of this blog we’ll explore how resources are saved to storage and made publicly accessible. Your account will have an address associated with it which will be extremely important for accessing items in your storage. Think of your home address, it would be really hard to order from Amazon if you forgot your postal code or your street number.

Here is a link to get you started (you’ll also need the flow cli installed).

Transactions and Scripts

The only way you can interact with your contract (or any data on the blockchain for that matter) is through scripts or transactions and the conceptual difference between the two is quite simple. Scripts can only read from the blockchain, whereas transactions can read and modify data from the blockchain.

Common scripts would be used to get the metadata of an NFT, get a list of all the current owners of your NFTs or to get a list of the past owners. Common transactions could be to mint an NFT, setup a consumer’s account or transfer ownership of an NFT.

While the transactions and scripts you write are the ones doing all the heavy lifting, they are always implementing contracts. For instance, the act of minting an NFT through a transaction will always require the use of functions (such as createToken) that you define in your contract.

One last point that I will mention is that since transactions are modifying data on the blockchain there is a ‘gas fee’. Therefore every time the transaction is executed the person who executed it must pay a small fee. However there is a test environment that exists on Flow for development purposes.

Making an NFT

FLOW NFT standard

To make your own NFT all you need is a contract with a few special attributes. To make sure there isn’t any confusion, Flow created a contract that defines a standard that all non fungible tokens must meet. These standards are implemented using interfaces, click here to learn more. For your contract to be up to Flow’s standards it needs the following.

Your contract must have

  1. A NFT resource (and a function to create one createToken)

The NFT resource that your contract must contain has fairly few required attributes. As long as your NFT resource has an ‘id’ field it is good to go!

(code from flow’s NonFungibleToken.cdc contract)


2. A collection resource (and a function to create one createEmptyCollection)

The collection on the other hand is a little more complex. As we know, resources are unique, however, this poses a problem to users who would like to own more than one of our NFTs. Flow’s solution is the Collection resource. A collection, is simply a container built to store multiples of our NFT resource (every NFT has their own unique collection so we must define ours!).

Our collection resource must have an ownedNFTs field which stores a list of all the NFTs being stored in that collection. A withdraw function which allows us to remove NFTs from the collection. A deposit function which lets us add an NFT into the collection. A getIDs function which returns a list of all the IDs of the NFTs in the collection. Last but certainly not least, there must be a borrowNFT function which takes in an ID and returns the NFT which posses that ID.

(code from flow’s NonFungibleToken.cdc contract)


3. A publicCollection resource interface.

Lastly, we must have a publicCollection resource interface. Interfaces are a more complicated topic so I’ll give more of a conceptual overview of what this resource accomplishes. In sum, a resource interface is a restricted version of a resource. Our publicCollection will be a version of our collection that anyone will be able to access, so we want to remove some functionality to make sure that someone can’t just withdraw all of your NFTs.

Our publicCollection will restrict our Collection to 3 functions, deposit, getIDs and borrowNFT. As a clarification, borrowNFT only returns a reference to the NFT so don’t worry about someone borrowing your favourite NFT and messing it up.

(code from flow’s NonFungibleToken.cdc contract)


Finally, with these resources and resource interface your contract will be up to the Flow NFT standards! If you want to have some Metadata associated with your token make sure to view this contract to see how you can give your token some standardized Metadata which will allow you to post it on a marketplace and make some royalties!

Mint transaction

To mint a NFT there are a few steps, as we now know NFTs need to reside in a collection, but where do these collections reside? Well, if you recall the ‘Smart Contracts’ portion of this post, I mentioned that accounts are essentially storage, therefore step 1 of minting an NFT is to save an empty collection to our storage using our createEmptyCollection function.

In the following code excerpts I’ll be using ‘MyNFT’ as a placeholder for the name of an NFT contract:

The step 2 was foreshadowed in the previous section, we must link a publicCollection to a public section of our storage (paths beginning with /public are public and /storage are private).

Step 3 is to borrow the collection we just created.

Finally, we create an NFT using our createToken function and deposit it into our collection using our deposit function that we defined in our Collection resource.

And with that our minting transaction is complete. Hopefully you have gained a good conceptual understanding of the NFT creation process through this post and if ever you want to explore the world of NFTs on the flow blockchain there is no better time to start than the present! Even as a developer I found the world of NFTs very intimidating at first but once you get started you’ll be amazed at what you can do!

All Comments