Cointime

Download App
iOS & Android

Creating ERC721 NFT Smart Contracts on Flow Blockchain with Cadence Programming Language: A Comprehensive Guide with Code Examples

Validated Individual Expert

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:

  1. Install the Flow CLI by following the instructions on the official Flow documentation.
  2. Create a new directory for your project and navigate to it in your terminal.
  3. Initialize a new Flow project by running flow init in your terminal. This will create a new flow.json file in your project directory.
  4. Create a new Cadence file in your project directory called MyNFT.cdc and paste in the ERC721 smart contract implementation that we just created.
  5. Deploy the contract by running the following command in your terminal: flow project deploy --network=emulator. This will deploy the contract on the Flow emulator network.

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

  1. Mint a new token:
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.

NFT
Comments

All Comments

Recommended for you

  • Net inflows into spot Bitcoin ETFs reached $179 million on March 28

    Spot on Chain, a blockchain data monitoring platform, posted on social media that the net inflow of spot bitcoin ETF on March 28th reached 179 million US dollars, a decrease of 26.9% compared to the previous trading day. After 54 trading days, the total net inflow accumulated to 12.13 billion US dollars, which is the level before the last fully negative trading week. BlackRock's iShares Bitcoin ETF (IBIT) and Grayscale's GBTC both saw a significant slowdown in daily inflows and outflows on March 28th.

  • Bitcoin spot ETF had a total net inflow of US$179 million yesterday, and the ETF net asset ratio reached 4.25%

    According to SoSoValue data, the Bitcoin spot ETF had a total net inflow of $179 million yesterday (March 28th, US Eastern Time).Yesterday, Grayscale's ETF GBTC had a net outflow of $104 million, and its historical net outflow is $14.77 billion. The Bitcoin spot ETF with the highest net inflow yesterday was BlackRock's ETF IBIT, with a net inflow of approximately $95.12 million, and its historical total net inflow has reached $13.96 billion. The second is Fidelity's ETF FBTC, with a net inflow of approximately $68.09 million yesterday, and its historical total net inflow has reached $7.56 billion.As of now, the total net asset value of Bitcoin spot ETF is $59.1 billion, and the ETF net asset ratio (market value compared to the total market value of Bitcoin) is 4.25%, with a historical total net inflow of $12.12 billion.

  • Ethereum Inscription ETHS rose over 95% in 24H

    CoinGecko data shows that Ethereum Inscription ETHS has risen by 95.9% in the last 24 hours, now reporting at 7.51 USDT. Earlier, Ethereum founder Vitalik released the latest long article "Ethereum has blobs. Where do we go from here?". As a result of this news, the price of Ethereum Inscription ETHS soared.

  • Binance exec sues Nigeria’s National Security Agency over detention

    According to CoinGape, Tigran Gambaryan, a detained executive of Binance, has filed a lawsuit against the National Security Adviser (NSA) and the Economic and Financial Crimes Commission (EFCC) in Nigeria. Local media reported that on March 28th, Tigran Gambaryan sued the National Security Agency, accusing it of violating his basic human rights and seeking five major remedies from the court.He urged the court to approve the return of his passport and to release him immediately after more than three weeks of detention. He also requested a ban on future detention in similar investigations and demanded public apologies from the National Security Agency and the EFCC.In addition, he requested that the court pay the full amount of compensation for the lawsuit.

  • Vitalik: As L2 transaction costs decrease, there’s no reason why Ethereum can’t be widely adopted

    After the upgrade and introduction of blobs on Ethereum Dencun, Ethereum founder Vitalik Buterin shared his insights on the future direction of Ethereum's expansion. Vitalik emphasized the transformation of Ethereum's expansion from basic expansion work to centralized, progressive enhancement. Vitalik also stated that developers' focus will shift to the application layer. Ethereum will maintain its roadmap centered on L2, and applications will migrate from L1 to L2 to benefit from faster and more cost-effective transactions. An upcoming upgrade is Data Availability Sampling (DAS), which aims to increase the data space for each slot to 16 MB. Progressive expansion improvements include gradually increasing blob capacity, improving data compression, and EIP-7623 (aimed at reducing maximum block size). Vitalik pointed out that with the reduction of L2 transaction costs, there is no reason why Ethereum should not be widely adopted.

  • RWA project Midas completes US$8.75 million in seed round financing

    According to Jinse Finance, RWA project Midas has completed a seed round of financing worth $8.75 million, led by BlockTower, Framework, and HV Capital, with participation from institutions such as Coinbase Ventures, Ledger, GSR, Hack VC, Axelar, and FJ Labs.

  • Two Different Sentences for FTX Founder Sam Bankman-Fried: 25 Years and $11 Billion vs. 16 Months and $8 Billion Losses

    The founder of FTX, Sam Bankman-Fried, has been sentenced to 16 months in prison and charged with eight criminal counts, including money laundering and conspiracy. He was involved in a scheme that caused customers to lose $8 billion and allegedly diverted customer funds to Alameda. Bankman-Fried's lawyers had requested a lighter sentence, but the judge rejected their argument that the collapsed company had vowed to return money to its customers. Prosecutors had sought up to 50 years in prison for Bankman-Fried.

  • ON–216: NFTs

    Coverage on NodeMonkes, Pudgy Penguins, CryptoPunks, Mad Lads, and NFTs in Safes.

  • Cointime March 24th News Express

    1.Moonbeam has completed the airdrop distribution of Polkadot ecological meme currency PINK2.The total number of Ordinals inscriptions minted exceeded 63 million, and the fee income exceeded 400 million US dollars.3.BOME founder: 2543 SOL will be transferred to the new address and sent to 415 wallets as a reward refund4.BottoDAO, a decentralized autonomous organization focusing on digital art NFTs, completed US$1.67 million in financing, led by 1kx5.The current open interest on Binance BTC contracts is approximately $7.13 billion6. Polyhedra Network: We are working on introducing zero-knowledge proof technology to Bitcoin to realize smart contract functions and high-speed cross-chain bridging.8.Stable currency project DYAD has been launched on the KEROSENEN airdrop query website 7.After the Ethereum Dencun upgrade, the L2 rollup gas cost for publishing Chainlink oracle reports dropped by 99% 9.Partisia token MPC was launched on multiple exchanges such as Kucoin, and an airdrop of 25 million tokens was launched to encourage ecological participation. 10.L2 Tech to Fuel Bitcoin (BTC) Price Rise

  • Cointime March 17th News Express

    1.Derivatives trading platform D2X completed US$10 million in Series A financing, led by Point72 Ventures2.6 wallets received ARB from the vesting contract and deposited 8.95 million ARB to Binance3.BOME TOP1 holders will sell 190 million BOME for the first time, making a profit of US$3.76 million4.Manta Network joins hands with ether.fi to launch the first phase of Restaking Paradigm, staking ETH to earn double EtherFi airdrop points5.A giant whale took out 1,000 MKR from Aave and sold them in batches, worth $2.88 million6.Bitcoin fee income was only about $20.3 million this week, a drop of more than 33%7.BOME Token Price Surge Reflects Cryptocurrency Market Dynamics8.ETHVietnam anonymous MACI voting is officially launched. This is the first time aMACI voting technology has been used in a large-scale encryption event.9.Bitcoin Whales Withdraw Massive BTC Reserve From Exchanges, Impacting Bitcoin Price Surge10.USDC circulation increased by 1.3 billion in the past 7 days