Developing an ERC721 Non-Fungible Token in Solidity Without Libraries

In the realm of blockchain technology, Non-Fungible Tokens (NFTs) have gained significant attention for their unique use cases in art, collectibles, gaming, and more. An NFT represents a unique asset that cannot be exchanged, copied, substituted, or divided. Each token is unique, much like human beings or even unique kittens.

Understanding ERC721

The Ethereum Foundation developed the ERC721 standard to represent NFTs. This standard defines a table of ownership rights, ensuring that crypto wallets, brokers, and even auctions can work with NFTs on Ethereum and other EVM (Ethereum Virtual Machine) blockchains. Since its inception in 2017, the ERC721 standard has been authored by several notable contributors, including William Entriken, Dieter Shirley, Jacob Evans, and Nastassia Sachs.

Essential Functions of ERC721

The ERC721 standard includes several functions that help describe and manage NFTs. These functions are crucial for owning, transferring, and approving NFTs. Let's explore the most important functions in detail:

Ownership Functions

Ownership functions describe who the token owners are:

balanceOf(address _owner) - Returns the number of NFTs owned by the specified address.

ownerOf(uint256 _tokenId) - Returns the owner of the NFT with the specified token ID.

Transfer Functions

Transfer functions help to manage the transfer of NFTs:

safeTransferFrom(address _from, address _to, uint256 _tokenId) - Transfers the specified NFT from the _from address to the _to address, ensuring that the recipient is aware of the ERC721 standard.

safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) - Similar to the function above but includes the option to send additional data to the recipient.

approve(address _approved, uint256 _tokenId) - Grants rights to the specified address to transfer the NFT with the specified token ID.

getApproved(uint256 _tokenId) - Returns the address of the wallet approved to transfer the NFT with the specified token ID.

setApprovalForAll(address _operator, bool _approved) - Approves or removes approval for all the NFTs belonging to the caller to be transferred by _operator.

isApprovedForAll(address _owner, address _operator) - Checks if the _operator is allowed to transfer NFTs for the _owner.

Events

Events in the ERC721 standard are used to notify about changes in NFT ownership. These can be used by web frontends to update accordingly. Here are the main events:

Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) - Emitted when a token with the specified ID is transferred from one address to another.

Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) - Emitted when approval rights are given to the specified address for a specific token ID.

ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) - Emitted when the _owner gives or removes approval for all NFTs owned to be transferred by _operator.

Metadata Extension

A commonly used extension to the ERC721 standard allows for the inclusion of metadata in a JSON format. This metadata can represent information such as a name, symbol, and token URI. Crypto wallets can retrieve this information using the following functions:

name() - Returns a descriptive name of the NFT.

sxymbol() - Returns the symbol of the NFT.

tokenURI(uint256 _tokenId) - Returns the URL to a JSON file that describes the NFT. This metadata is often stored on IPFS (InterPlanetary File System).

Creating an ERC721 Smart Contract in Solidity

Now that we understand the key functions and events of the ERC721 standard, let's dive into how to create a custom ERC721 smart contract without relying on any libraries or frameworks. This process involves defining the contract, implementing the necessary functions, and ensuring the security and correctness of the code.

Step 1: Define the Contract

First, define the contract with the name MyERC721. The contract should inherit from the Context and ERC721 contracts provided by the open-source Solidity ecosystem. The constructor sets the values of the creator and totalSupply:

pragma solidity ^0.8.0;
import 

Step 2: Implement Ownership Functions

Implement the ownership functions by overriding the necessary functions from the base ERC721 contract:

contract MyERC721 is Context, ERC721 {
    constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {}
    function balanceOf(address _owner) public view override returns (uint256) {
        return (_owner);
    }
    function ownerOf(uint256 _tokenId) public view override returns (address) {
        return super.ownerOf(_tokenId);
    }
}

Step 3: Implement Transfer Functions

Implement the transfer functions to handle the transfer of NFTs:

contract MyERC721 is Context, ERC721 {
    // Ownership functions implementation
    function _safeTransfer(address _from, address _to, uint256 _tokenId, bytes memory _data) internal override {
        super._safeTransfer(_from, _to, _tokenId, _data);
    }
    function _approve(address _approved, uint256 _tokenId) internal override {
        super._approve(_approved, _tokenId);
    }
    function _setApprovalForAll(address _operator, bool _approved) internal override {
        super._setApprovalForAll(_operator, _approved);
    }
}

Step 4: Implement Events

Implement the events to notify about changes in NFT ownership:

contract MyERC721 is Context, ERC721 {
    // Transfer functions implementation
    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
}

Step 5: Implement Metadata Extension

Implement the metadata extension to include additional information about the NFT:

contract MyERC721 is Context, ERC721 {
    // Events implementation
    function name() public view override returns (string memory) {
        return ();
    }
    function symbol() public view override returns (string memory) {
        return ();
    }
    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        return (_tokenId);
    }
}

Conclusion

By understanding and implementing the ERC721 standard in Solidity, developers can create their own unique non-fungible tokens without relying on libraries or frameworks. This process involves defining the contract, implementing ownership functions, transfer functions, events, and metadata extension. With careful coding and thorough testing, developers can build a secure and functional ERC721 smart contract that can be used for various NFT applications.

Related Topics

Keyword: ERC721, Smart Contract, Non-Fungible Tokens

Topics:

Blockchain - Understanding the basics of blockchain technology and its applications.

NFTs - Exploring the world of non-fungible tokens and their use cases.

Ethereum - Learning about the Ethereum network and its role in NFTs.

By exploring these topics further, developers can gain a comprehensive understanding of how to work with NFTs and build more complex decentralized applications (dApps).