Recently, non-fungible tokens (NFTs) have become incredibly popular for digitally representing ownership and authenticity. NFTs use blockchain to tokenize unique digital assets such as art, videos, avatars, music, you name it. While NFTs provide new economic and creative possibilities, the evolving and complex nature of the underlying technologies makes navigating the NFT landscape challenging.

One important standard for NFTs is ERC-721, which was introduced in 2017. It provides a baseline for representing unique digital assets on Ethereum and other blockchains. As NFT usage has surged, limitations of ERC-721 have become apparent, and solutions have been created to some extent. This article explores the history, and related standards driving NFT innovation. We will discuss the context of ERC-721's creation, and its limitations, and examine new standards aiming to enhance the classification of NFT metadata, on-chain logic, and interoperability. We aim to provide insights into how foundational standards are shaping and adapting to the rapidly changing NFT ecosystem.

The Genesis of ERC-721

The ERC-721 standard has become a fundamental blueprint for making NFTs work and creating new ways of owning digital items on blockchain networks. First proposed in 2017 by Dieter Shirley, an Ethereum developer, ERC-721 establishes a common interface for NFTs, digital assets with unique identifications and metadata intended to represent provably scarce items like collectibles, artworks, videos, music and more.

Unlike ERC-20, which was made for easily exchangeable tokens, ERC-721 is all about keeping tabs on NFTs that are one-of-a-kind and can't be swapped for something else. Key features of ERC-721 include:

  • Keeping track of who owns unique IDs: ERC-721 links NFTs with IDs, like numbers or codes, and says who owns each ID through their wallet address. This makes it easy to know who owns which tokens i.e. mapping of tokens to owners.

  • Transferring token ownership: ERC-721 defines transfer functions for securely exchanging control and possession of tokens between owners.

  • Getting standardized details about a token: Methods for connecting extra info like names, descriptions, media, and features to a token (attributes).

Since its launch, ERC-721 sparked a ton of NFT experiments, like the famous CryptoKitties game. These digital collectibles showed that owning and proving the rarity of digital things without relying on trust was totally doable. But as the NFT idea grew, people started thinking about how to upgrade ERC-721.

Evolution of ERC-721

Since its inception in 2017, ERC-721 has seen some significant updates, triggering lots of cool new ideas and projects in the world of NFTs.

By early 2018, just under a year from Shirley's first ERC-721 draft, the standard was officially accepted and deployed to the Ethereum mainnet. This kickstarted the development of the first projects that stuck to the ERC-721 rules. CryptoKitties, one of the earliest fun NFT apps on Ethereum, used ERC-721 to make its virtual cats scarce and to show who owned them. CryptoKitties proved that NFTs could work for digital collectibles, on-chain gaming, and even moving cute cats to other platforms.

But, even with its cool ideas, projects like CryptoKitties revealed some problems in the early ERC-721 versions like inefficient token enumeration and undefined metadata. So, in 2018, a new and improved version called ERC-721 Metadata Extension was suggested. It made it easier to connect extra info, like pictures and details, to the basic ownership records.

ERC-721 kept evolving. ERC-721 Enumerable was introduced to optimize gas costs for querying token lists and owners. In 2021, plans started for an ambitious ERC-721A upgrade to maximize contract optimization and interoperability while retaining backward compatibility.

Today, ERC-721 is still the go-to way for owning NFTs on Ethereum and elsewhere. Even though new things are popping up, ERC-721 has a mix of history and improvements that will probably keep it important for NFTs in the future.

ERC-721's Impact on the NFT Ecosystem

Pioneering projects on Ethereum showed that NFTs could work, but ERC-721 did more than that. It brought crucial blockchain abilities that went beyond the early uses. By clearly and securely marking digital ownership, ERC-721 made it possible to track identity, authenticity, and the history of unique things.

This impact reached beyond just tech, it affected everyday life. With ERC-721, things like event tickets, resumes, luxury items, certificates, cards, and more could connect to user identities on networks. This connection made sure that the items were real and had a clear history. Musicians and filmmakers tested selling tokenized albums or movies, keeping a share of the money even when the items were resold. People even turned tweets into symbolic collectibles using ERC-721 rules.

At the same time, ERC-721 became the backbone for the growing metaverse and Web3 ecosystems, where digital and physical ownership mix. Systems for avatars, virtual worlds, and blockchain games relied on ERC-721 to make things rare, secure, and transparent. As more people do things online, these mechanics become more important.

What's big about ERC-721 is that it showed that blockchain isn't just for moving money around or running programs. It's also about digital ownership, and that idea can change how we think about identity, working together, taking part in decisions, creative jobs, and much more. In many ways, ERC-721 laid the groundwork for imagining this next generation of blockchain-powered cooperation and coordination.

Technical Guide

ERC-721 outlines interfaces that define the key functions and events that make up the ERC-721 standard for representing NFTs on Ethereum:


  • Transfer: This is emitted when an NFT is transferred from one address to another.

  • Approval: This is emitted when an address is approved to take ownership of an NFT.

  • ApprovalForAll: This is emitted when an operator is approved/revoked to manage all NFTs of an owner.


  • balanceOf(): Return the number of NFTs owned by an address.

  • ownerOf(): Get the address of the owner of a particular NFT.

  • safeTransferFrom(): Securely transfer an NFT from one address to another.

  • transferFrom(): This is used to transfer an NFT from one address to another.

  • approve(): Approve an address to take ownership of an NFT.

  • setApprovalForAll(): Approve/revoke an operator to manage all NFTs of msg.sender (current caller of a function).

  • getApproved(): Gets the approved address for a single NFT.

  • isApprovedForAll(): Check if an address is an operator for another address.

Any ERC-721 smart contract will need to implement this interface to allow integration with other Ethereum applications expecting these entry points. It provides the basic blueprint for trustless, interoperable NFT ownership and transfer.

OpenZeppelin Contracts are a popular library for secure smart contract development including modular, community-vetted implementations of standards like ERC-721.

Now let’s write a simple NFT contract using the OpenZeppelin library to make production faster. But before you proceed ensure you have a Web3 wallet setup like Metamask.

Tutorial: Creating an NFT Contract

Creating and deploying a simple NFT contract using OpenZeppelin's libraries in Remix, an Ethereum IDE, involves the following steps:


Setting Up Remix

Go to Remix Ethereum IDE here. Remix runs in your browser and doesn't require any installation. Here is what the IDE looks like:

In the File Explorers tab, create a new file by clicking the + icon. Name it something like MyNFT.sol.


Writing the Smart Contract

At the top of your MyNFT.sol file, import OpenZeppelin's ERC-721 libraries. You can use the following import statement:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

Create a new contract that inherits from OpenZeppelin's ERC721 like so:

contract MyNFT is ERC721, Ownable {
    constructor() ERC721("MyNFT", "MNF") Ownable(msg.sender) {}

    function safeMint(address to, uint256 tokenId) public onlyOwner {
        _safeMint(to, tokenId);

Let's break down the key components of MyNFT contract.

SPDX License Identifier

This is a comment indicating the license under which this code is released. Here, it's the MIT License, which is a permissive free software license.

// SPDX-License-Identifier: MIT

Pragma Directive

This specifies the compiler version that the contract is written for. The ‘^’ symbol means it is compatible with any version of the compiler from ‘0.8.4’ upwards, but less than ‘0.9.0’.

pragma solidity ^0.8.4;

Imports from OpenZeppelin

These lines import two contracts from the OpenZeppelin library:

  • ERC721.sol: This is the contract that implements the ERC-721 standard for NFTs. It provides basic functionality for tracking and transferring NFTs.

  • Ownable.sol: This provides basic authorization control functions. It simplifies the implementation of "user permissions".

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

Contract Declaration

This declares a new contract called MyNFT, which inherits from both ERC721 and Ownable. Inheritance means MyNFT will have all the functions and properties of ERC721 and the Ownable contract.

contract MyNFT is ERC721, Ownable {


The constructor is a special function that is only called once when the contract is deployed.

  • ERC721("MyNFT", "MNF") initializes the base ERC721 contract with the name ("MyNFT") and the chosen symbol (”MNF”) of the NFT. Note that you can always customize the name and symbol to the one you want.

  • Ownable(msg.sender) sets the deployer of the contract (the one who initiates this contract on the blockchain) as the owner of the contract. This is part of the Ownable functionality, allowing certain functions to be restricted to the owner.

constructor() ERC721("MyNFT", "MNF") Ownable(msg.sender) {}

safeMint() Function

This is a public function that allows the owner (that is the deployer) of the contract to mint (create) new NFTs.

  • onlyOwner is a modifier from the Ownable contract that restricts the safeMint function so that only the contract owner can call it.

  • _safeMint(to, tokenId) is an internal function from the ERC721 contract that safely mints a new token with the tokenId and assigns it to the to address. The "safe" in safeMint refers to checks ensuring that if the target address is a contract, it must know how to handle ERC721 tokens. If the target address is not a contract, or if it is a contract that can handle ERC721 tokens, the minting proceeds.

function safeMint(address to, uint256 tokenId) public onlyOwner {
        safeMint(to, tokenId);

Step 3: Compiling the Contract

Now that the contract is ready, it's time to compile it. In the left panel of REMIX, click on the Solidity Compiler icon. Click the Compile MyNFT.sol button. You can also turn on Auto Compile on Remix to automatically compile your contracts as you are writing them. Once the solidity icon on Remix shows a green checkmark ✅, your contract has been successfully compiled.


Deploying the Contract

Before deploying, you need to connect Remix to an Ethereum wallet like MetaMask. This is required for deploying the contract to the blockchain. Select the Ethereum network you want to deploy to. For testing, it's advisable to use a test network like Sepolia or Mumbai. Get faucet tokens here if you don’t have enough.

Now, go to the Deploy & Run Transactions tab. Select the Injected Provider - Metamask environment to connect to your wallet. Then click on Deploy to deploy your contract.


Interaction/Minting NFTs

After deploying, you can interact with your contract through the Remix interface. You will it in the Deployed Contracts part of the interface.

Open it and use the safeMint function to mint an NFT by providing the recipient's address, and a unique token ID. Click on the transact button, and confirm the transaction.

You can also interact with functions as needed. Depending on your requirements, you might need to modify or expand upon this code.


ERC-721 has evolved rapidly since its inception in 2017, becoming a widely adopted NFT standard in under 5 years. It highlights the strength of community collaboration in blockchain. While it remains important for digital ownership, ongoing improvements are vital in the ever-changing blockchain environment. ERC-721 has undergone significant enhancements, including gas optimizations and improved metadata and interoperability.

Now, we're seeing new kinds of NFTs like dynamic NFTs that can change over time, fractional NFTs that let many people own a piece of an NFT, and NFTs that give special access or privileges. The story of ERC-721 shows how blockchain can change and grow in exciting ways.

References & Further Reading