NFT Standards & CreatingYour Own NFT with ERC-721 | by Sirharry

Imagine this: the world is suddenly infatuated with digital cats in 2017, and CryptoKitties are clogging the Ethereum network. This was a turning point that demonstrated the potential of Non-Fungible Tokens (NFTs), not just a passing trend. But behind these digital felines lay a crucial piece of infrastructure: the ERC-721 standard.

So what exactly is an NFT standard?

An NFT standard is a set of rules and guidelines that define how non-fungible tokens (NFTs) are created, managed, and interacted with on a blockchain. It refers to the set of rules, procedures, and specifications that establishes the composition, characteristics, and capabilities of Non-Fungible Tokens (NFTs). By establishing a consistent framework for NFT creation, minting, transfer, and trading, these standards guarantee compatibility and interoperability across various blockchain networks and platforms.

Why are NFT Standards Necessary?

Without a standard, each NFT creator would be free to define their own rules, which would lead to:

• Incompatibility: NFTs created on one platform might not be recognized or transferable on another.
• Complexity: Developers would need to create custom logic for each NFT, making the ecosystem fragmented and inefficient.
• Lack of Interoperability: Users wouldn’t be able to seamlessly manage their NFTs across different platforms and marketplaces.
• Limited Functionality: The features and functionality of NFTs would vary greatly depending on how they were defined by each individual creator or platform.

Key Components of an NFT Standard

An NFT standard defines several important aspects of how NFTs function, including:

• Token ID (tokenId): Each NFT must have a unique ID, ensuring it’s distinguishable from any other NFT.
• Metadata: Defines how NFT properties are linked with the token, typically through an IPFS URI (for images, videos etc.).
• Ownership: How ownership is transferred and tracked on the blockchain.
• Interfaces (Functions): Standard methods for interacting with the NFT, like transferring ownership (transferFrom), checking the owner (ownerOf), etc.
• Smart Contract Logic: Specifies the rules governing minting, burning, and other operations.

Popular NFT Standards

Several NFT standards exist, each with its unique characteristics:

• ERC-721 (Ethereum): The most popular and widely adopted standard for NFTs, defining non-fungible tokens, where each token is unique. It is typically used for digital art, collectibles, and virtual real estate. Key Concept: One token = one unique asset.
• ERC-1155 (Ethereum): A more flexible standard that allows for both fungible (like multiple copies of a game item) and non-fungible tokens within the same smart contract. It is widely used for in-game items, digital collectibles with different rarities, and digital tickets. Key Concept: One token can represent multiple copies of the same asset, or a single unique asset.
• ERC-998 (Ethereum): Allows NFTs to “own” other NFTs, enabling more complex ownership structures (for example an NFT that represents a virtual character with attached items, and their own unique NFTs). Key Concept: “Composable” NFTs that can hold other NFTs.
• Other Chains’ Standards: Blockchains like Solana, Tezos, Flow, and others have their own NFT standards, each with its specific features and functionalities. These often incorporate different technical implementations, and can have different properties.

NFT Creation Process Using ERC-721 Standard

To solidify our understanding of NFT standard, I will be walking you through the creation process of an NFT using the ERC-721 standard on Ethereum. I’ll guide you through the process using some of the tools we have at hand.

Phase 1: Preparation

1. Set up a Metamask Wallet:

• Install MetaMask as a browser extension or mobile app.
• Create a new wallet (or import an existing one).
• Secure your seed phrase in a safe location.
• Select the Ethereum Mainnet network (or a testnet like Goerli/Sepolia for experimentation).
• Get testnet faucet like SepoliaETH or have some Ethereum in your wallet incase you are using Mainnet network (You’ll need this Ether to cover gas fees).

2. Choose Your Digital Asset:

Decide what you want to turn into an NFT. This can be:

• An image (JPEG, PNG, GIF).
• A video (MP4, MOV).
• An audio file (MP3, WAV).
• A 3D model (GLB, OBJ).
• A text document, or any other digital file you want to link to the NFT.
• Make sure the file is ready and optimized for uploading.

3. Upload your NFT file to IPFS

• Upload your digital asset to IPFS. You can use services like Pinata, Web3.storage, or IPFS Desktop. In our case, we’ll be using Pinata
• Upload your NFT asset quickly by dragging and dropping it or clicking the add button at the top right-hand corner to select files from your computer. In this guide, we use the image below.

• After uploading, click the file name in the Files tab and a new tab will open. Copy URL of the new tab which represent the IPFS URL of the NFT asset. See screenshot below for how your final NFT asset IPFS URL will look like.

https://jade-familiar-guineafowl-342.mypinata.cloud/ipfs/bafybeigls5dcgqbjwm3hoyryjteevhmdwecn6rd6fnzg4ii74u6dude2za

4. Prepare the Metadata:

• name: The name of your NFT.
• description: A brief description.
• image: Link to your NFT asset on Pinata IPFS.
• attributes (optional): Any additional properties that define your NFT

Example JSON metadata:

{
"name": "My NFT",
"description": "This is my first NFT created with ERC-721",
"image": "https://jade-familiar-guineafowl-342.mypinata.cloud/ipfs/bafybeigls5dcgqbjwm3hoyryjteevhmdwecn6rd6fnzg4ii74u6dude2za",
"attributes": [
{
"trait_type": "Type",
"value": "Awesome"
}
]
}

5. Upload to IPFS (InterPlanetary File System):

• Use a decentralized file storage service like IPFS.
• Upload both your digital asset and metadata file to IPFS. You can use services like Pinata, Web3.storage, or IPFS Desktop. In our case we’re using Pinata.
• Obtain the IPFS Content Identifier (CID) for both your digital asset and metadata. Note these CIDs down.

Phase 2: Minting the NFT

You can mint an ERC-721 NFT through multiple methods. Popular options are: using a no-code minting platform like OpenSea website, and minting using code (Smart Contract Interaction). In our case, we’ll be using minting using code (Smart Contract Interaction).

Minting Using Code (Smart Contract Interaction)

This method is more technical, and aimed at experienced developers who prefer to interact directly with the smart contract:

Select an ERC-721 Smart Contract:

• You can either deploy a pre-existing ERC-721 smart contract (like the one provided by OpenZeppelin), or create your own from scratch. In our case, we’ll be using the one provided by OpenZeppelin ERC-721 contract to create our NFT. With OpenZeppelin, we don’t need to write the whole ERC-721 interface. Instead, we can import the library contract and use its functions.
• Deploy the contract to the Ethereum network using a deployment tool like Remix, Hardhat, or Truffle. In our case, we’ll be using the one provided by Remix

1. Open Remix:

2. Create a New Solidity File:

• In the Remix file explorer (left side), click on “contracts”.
• Create a new file with any name (e.g., MyNFT.sol) inside the contract folder.

3. Paste the Smart Contract Code:

You can use a simple, existing ERC-721 implementation as a base. For this, I recommend the OpenZeppelin library, which provides secure, audited contracts:

• Copy the code below into your new Solidity file:

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MyNFT is ERC721, Ownable {
uint16 private TOKEN_CAP = 4;
uint256 private _nextTokenId;
constructor()
ERC721("MyNFT", "MNFT")
Ownable(msg.sender)
{}
function _baseURI() internal pure override returns (string memory) {
return "ipfs://bafkreihgh3jh47prbwk64afx6lpz66jktoz4qhtgvgoldsuxvec5uhx52i/";
}
function safeMint(address to) public onlyOwner {
require (_nextTokenId <= TOKEN_CAP, "Token cap exceeded");
uint256 tokenId = _nextTokenId++;
_safeMint(to, tokenId);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireOwned(tokenId);
return string(abi.encodePacked(_baseURI(), Strings.toString(tokenId), ".json"));
}
}

Note the following:

• MyNFT: The name of the contract
• MNFT: The symbol of the contract
• string public baseURI: This is the base URI for your NFTs, and this must point to the folder where your JSON metadata files are located. In our case it is “ipfs://bafkreihgh3jh47prbwk64afx6lpz66jktoz4qhtgvgoldsuxvec5uhx52i/”
• safeMint: Function used to mint new NFTs
• tokenURI: Function that returns the URI of the metadata for each NFT.

4. Compile the Smart Contract:

• On the left side, click on the “Solidity compiler” icon.
• Select a suitable Solidity compiler version (e.g., 0.8.19).
• Click on the blue “Compile MyNFT.sol” button. If it compiles, you should see a green check mark.

5. Deploy the Smart Contract:

• Click on the “Deploy & Run Transactions” icon.
• In the “Environment” dropdown, select “Injected Provider — Metamask.”
• Make sure your Metamask wallet is connected, and you have selected the network where you will deploy (Testnet if you are still experimenting).
• In the “Contract” dropdown, select “MyNFT.”
• Click “Deploy.”
• You will be prompted by MetaMask to confirm the deployment transaction, and pay the gas fees.
• Wait for the transaction to be mined. Once confirmed, your smart contract is deployed.
• Copy the contract address and save it, we’ll need this later.

Phase 3: Minting the NFT

1. Interact with your deployed smart contract:

• In the “Deploy & Run Transactions” section of Remix, you should see your deployed contract.
• You will see a number of functions in the deployed contract, in the section called Deployed Contracts.
• Click the dropdown next to the deployed MyNFT contract.
• Find the safeMint function, and input the wallet address where the token will be minted.
• Click safeMint. This will open up MetaMask to confirm the transaction and gas fees.
• Confirm the transaction, and wait for it to be processed in the blockchain.

2. Verify Transaction:

• Once confirmed, your NFT is minted.
• You can find the tokenId value by expanding the logs of the transaction in the blockchain explorer of your network.

Phase 4: Post-Minting (Viewing on OpenSea)

If you deployed to a testnet, you can view your NFTs on OpenSea (testnets.opensea.io for testnets) while for mainnet you go to opensea.io or other NFT marketplaces once they index your contract.

Connect Wallet: Click the “Wallet” icon in the top right corner of the OpenSea website and connect your MetaMask wallet. Make sure you connect the same wallet you used to mint the NFTs.

1. Using Your Profile:

• Click on your profile icon in the top right corner.
• Select “Profile” from the dropdown menu.
• You should see your NFTs listed under the “Created” tab (if you minted them) or the “Collected” tab (if you transferred them to yourself).

2. Using the Contract Address:

• If you know the contract address of your NFT collection, you can search for it directly on OpenSea.
• Paste the contract address into the search bar on OpenSea testnet.
• This should take you to the collection page, where you can see all the NFTs associated with that contract.

Use Cases for NFTs and the ERC-721 Standard

Beyond digital art and collectibles, ERC-721 and other NFT standards (like ERC-1155 for semi-fungible tokens) have diverse use cases:

• Digital Identity: NFTs can represent verifiable credentials, like diplomas or licenses.
• Supply Chain Management: Tracking goods through their lifecycle, ensuring authenticity and provenance.
• Gaming: In-game assets, allowing players true ownership of their items.
• Real Estate: Tokenizing property ownership, streamlining transactions.

The Wrap-Up: A World of Possibilities

NFTs are more than just a passing fad. They’re a paradigm shift, a fundamental change in how we interact with digital ownership. The ERC-721 standard was a crucial building block, but the story is far from over.

As crypto natives, we’re not just passive observers. We’re the architects of this new digital frontier. So, go ahead, mint your creations, explore the possibilities, and become a part of this revolutionary technology. The blockchain is waiting.