The world of blockchain has been revolutionized by the emergence of non-fungible tokens (NFTs). These digital assets are unique and cannot be replicated, making them ideal for use cases such as art, collectibles, and gaming items. The ERC721 standard, developed by Ethereum, is one of the most popular NFT standards in use today. However, the limitations of the Ethereum network, such as high gas fees and scalability issues, have led to the emergence of alternative blockchain platforms for NFT development. One such platform is the Flow blockchain, which uses the Cadence programming language. In this article, we will explore how to create an ERC721 NFT smart contract on the Flow blockchain using Cadence, including code examples.

What is an ERC721 NFT?

An ERC721 NFT is a unique digital asset that is stored on the Ethereum blockchain. Each NFT is represented by a smart contract that contains metadata and ownership information. Unlike traditional cryptocurrencies, such as Bitcoin or Ethereum, which are fungible and interchangeable, each ERC721 NFT is unique and cannot be replicated. This uniqueness makes them ideal for use cases such as art, collectibles, and gaming items, where the value of an asset is determined by its uniqueness.

ERC721 smart contracts define a standard interface that enables NFTs to be created, owned, and traded on the Ethereum network. The ERC721 standard includes functions such as minting new tokens, transferring ownership of tokens, and querying token metadata.

What is the Flow Blockchain?

The Flow blockchain is a fast, decentralized, and developer-friendly blockchain platform designed for building high-performance applications and digital assets. Flow uses a unique architecture that separates the computation and storage layers, allowing for more efficient use of resources and faster transaction processing times. Flow also supports smart contracts written in the Cadence programming language, which is designed to be safe, easy to use, and secure.

Why Use Flow for NFT Development?

While Ethereum is the most popular blockchain platform for NFT development, it has several limitations that have led to the emergence of alternative platforms such as Flow. One of the main issues with Ethereum is the high gas fees required to execute transactions on the network. Gas fees are paid in Ethereum’s native currency, Ether, and can vary greatly depending on network congestion and transaction complexity. This can make it expensive to create, trade, and transfer NFTs on the Ethereum network.

Flow, on the other hand, has lower transaction fees and faster transaction processing times than Ethereum. This makes it more suitable for use cases such as gaming, where high transaction volumes are required. Additionally, Flow’s architecture is designed to be developer-friendly, with a focus on ease of use and security.

Creating an ERC721 NFT Smart Contract on Flow

To create an ERC721 NFT smart contract on the Flow blockchain, we will use Cadence. Cadence is a safe, easy-to-use, and secure programming language designed specifically for blockchain development. Cadence is built on top of the Flow blockchain, which means that developers can take advantage of Flow’s unique architecture and features.

The first step in creating an ERC721 NFT smart contract on Flow is to define the contract interface. The contract interface defines the functions and properties that will be exposed to the outside world. In our case, we will define the ERC721 standard interface, which includes functions such as minting new tokens, transferring ownership of tokens, and querying token metadata.

Here is an example of an ERC721 contract interface in Cadence:

pub contract ERC721 {  // Event that is emitted when a new token is minted  pub event Minted(tokenID: UInt64, owner: Address)  // Event that is emitted when a token is transferred  pub event Transferred(tokenID: UInt64, from: Address, to: Address)// Function to mint a new tokenpub fun mint(to: Address, tokenID: UInt64) {// TODO: Implement mint function}// Function to get the owner of a tokenpub fun ownerOf(tokenID: UInt64): Address? {// TODO: Implement ownerOf functionreturn nil}// Function to transfer ownership of a tokenpub fun transfer(from: Address, to: Address, tokenID: UInt64) {// TODO: Implement transfer function}}

This interface defines the functions and events that are required for an ERC721 smart contract. We have defined the `mint` function for minting new tokens, the `ownerOf` function for querying the owner of a token, and the `transfer` function for transferring ownership of a token.

Now that we have defined the interface for our ERC721 contract, we can start implementing the contract logic. In our implementation, we will use a dictionary to store the ownership information for each token. The key of the dictionary will be the token ID, and the value will be the address of the owner.

Here is an example of an ERC721 smart contract implementation in Cadence:

pub contract MyNFT: ERC721 {  // Dictionary to store the ownership information for each token  pub var tokenOwner: {UInt64: Address}  // Function to mint a new token  pub fun mint(to: Address, tokenID: UInt64) {    // Check that the token has not already been minted    if (tokenOwner[tokenID] != nil) {      panic("Token already exists")    }    // Mint the new token and set the owner to the specified address    tokenOwner[tokenID] = to    // Emit the Minted event    emit Minted(tokenID: tokenID, owner: to)  }  // Function to get the owner of a token  pub fun ownerOf(tokenID: UInt64): Address? {    // Return the owner address for the specified token ID    return tokenOwner[tokenID]  }  // Function to transfer ownership of a token  pub fun transfer(from: Address, to: Address, tokenID: UInt64) {    // Check that the sender is the current owner of the token    if (tokenOwner[tokenID] != from) {      panic("Sender is not the owner of the token")    }    // Transfer ownership of the token to the new address    tokenOwner[tokenID] = to    // Emit the Transferred event    emit Transferred(tokenID: tokenID, from: from, to: to)  }}

This implementation defines a contract called MyNFT that implements the ERC721 interface. We have defined the tokenOwner dictionary to store the ownership information for each token, and we have implemented the mint, ownerOf, and transfer functions.

The mint function checks that the token has not already been minted and then mints the new token by setting the owner to the specified address. We have also emitted the Minted event to notify external observers that a new token has been minted.

The ownerOf function simply returns the owner address for the specified token ID by looking up the value in the tokenOwner dictionary.

The transfer function checks that the sender is the current owner of the token and then transfers ownership of the token to the new address by updating the value in the tokenOwner dictionary. We have also emitted the Transferred event to notify external observers that the ownership of a token has been transferred.

We can now deploy this ERC721 smart contract on the Flow blockchain using the Flow CLI. Here are the steps to deploy the contract:

Once the contract is deployed, you can interact with it using the Flow CLI. Here are some examples of how to use the contract:

flow transactions send ./transactions/mint.cdc

This command will send a transaction to the contract to mint a new token.

2. Query the owner of a token:

flow scripts execute ./scripts/ownerOf.cdc

This command will execute a script to query the owner of a token.

3. Transfer ownership of a token:

flow transactions send ./transactions/transfer.cdc

This command will send a transaction to the contract to transfer ownership of a token.

In order to execute transactions and scripts on the Flow blockchain, we need to write Cadence code that interacts with the contract. Here is an example of how to do that in Cadence:

import FungibleToken from "./FungibleToken.cdc"import MyNFT from "./MyNFT.cdc"// Address of the contractlet contractAddress: Address = 0x01// Address of the token ownerlet ownerAddress: Address = 0x02// Address of the token recipientlet recipientAddress: Address = 0x03// Token ID of the token to mintlet tokenID: UInt64 = 1// Amount of tokens to transferlet amount: UInt64 = 10// Instantiate the FungibleToken contractlet tokenContract = getAccount(contractAddress)  .getContract<FungibleToken.FungibleToken>("FungibleToken")// Instantiate the MyNFT contractlet nftContract = getAccount(contractAddress)  .getContract<MyNFT.MyNFT>("MyNFT")// Mint a new tokennftContract.mint(to: ownerAddress, tokenID: tokenID)// Get the owner of a tokenlet owner = nftContract.ownerOf(tokenID: tokenID)// Transfer ownership of a tokennftContract.transfer(from: ownerAddress, to: recipientAddress, tokenID: tokenID)// Transfer tokenstokenContract.transfer(from: ownerAddress, to: recipientAddress, amount: amount)

In this example, we are importing the FungibleToken and MyNFT contracts that we created earlier. We are then instantiating these contracts using the getAccount function and calling their functions to interact with them.

We first mint a new token by calling the mint function on the MyNFT contract. We then get the owner of the token by calling the ownerOf function on the MyNFT contract.

We then transfer ownership of the token by calling the transfer function on the MyNFT contract. Finally, we transfer some FLOW tokens by calling the transfer function on the FungibleToken contract.

In conclusion, ERC721 tokens are a powerful tool for creating unique, indivisible digital assets on the blockchain. By using smart contracts, we can create ERC721 tokens that have specific properties and behaviors, such as being non-fungible, transferrable, and ownable. The Flow blockchain and the Cadence programming language provide an ideal environment for creating and deploying ERC721 contracts, with a high degree of security and performance.

Here is the final implementation of the ERC721 smart contract in Cadence:

import FlowToken from 0xFLOWTOKENADDRESSimport FungibleToken from "./FungibleToken.cdc"pub contract MyNFT: FungibleToken {    // Event emitted when a new token is minted    pub event Mint(tokenID: UInt64, to: Address)    // Event emitted when ownership of a token is transferred    pub event Transfer(tokenID: UInt64, from: Address, to: Address)    // Storage for token owner information    pub var owners: {UInt64: Address}    // Storage for the total supply of tokens    pub var totalSupply: UInt64    // Initialize the contract with an empty owners mapping    init() {        self.owners = {}        self.totalSupply = 0    }    // Mint a new token and assign ownership to the specified address    pub fun mint(to: Address, tokenID: UInt64) {        // Make sure the token ID is not already owned        assert(!self.exists(tokenID), message: "Token already exists")        // Assign ownership to the specified address        self.owners[tokenID] = to        // Increase the total supply of tokens        self.totalSupply += 1        // Emit a Mint event        emit Mint(tokenID: tokenID, to: to)    }    // Check if a token exists    pub fun exists(tokenID: UInt64): Bool {        return self.owners[tokenID] != nil    }    // Get the owner of a token    pub fun ownerOf(tokenID: UInt64): Address? {        return self.owners[tokenID]    }    // Transfer ownership of a token from one address to another    pub fun transfer(from: Address, to: Address, tokenID: UInt64) {        // Make sure the sender is the current owner of the token        assert(self.ownerOf(tokenID) == from, message: "Sender does not own token")        // Assign ownership to the new address        self.owners[tokenID] = to        // Emit a Transfer event        emit Transfer(tokenID: tokenID, from: from, to: to)    }    // Override the FungibleToken implementation to prevent tokens from being transferred    pub fun transfer(from: Address, to: Address, amount: UFix64) {        panic("ERC721 tokens are not transferrable with FungibleToken")    }    // Override the FungibleToken implementation to prevent tokens from being approved for transfer    pub fun approve(to: Address, amount: UFix64) {        panic("ERC721 tokens are not approvable with FungibleToken")    }    // Override the FungibleToken implementation to prevent tokens from being transferred from one address to another    pub fun transferFrom(from: Address, to: Address, amount: UFix64) {        panic("ERC721 tokens are not transferrable with FungibleToken")    }}

I hope this article has been helpful in understanding how to create and deploy ERC721 smart contracts on the Flow blockchain using the Cadence programming language. By following the examples and guidelines presented here, you can create your own unique digital assets and interact with them on the blockchain.

It’s important to note that the implementation of ERC721 tokens can vary depending on the specific use case and requirements of the project. For example, some projects may require additional functionality such as the ability to burn tokens or to add metadata to each token. These features can be added to the contract by modifying the implementation or by creating additional functions.

Additionally, it’s important to thoroughly test your smart contracts before deploying them to the blockchain. This can be done by creating automated tests that cover all possible scenarios and edge cases. The Flow blockchain provides a robust testing framework that can be used to test your contracts before deploying them to the mainnet.

In summary, ERC721 tokens are a powerful tool for creating unique, indivisible digital assets on the blockchain. The Flow blockchain and the Cadence programming language provide an ideal environment for creating and deploying ERC721 contracts, with a high degree of security and performance. By following the guidelines and examples presented in this article, you can create your own ERC721 tokens and interact with them on the blockchain.