Implementing ERC-721: Building Your Own NFT Contract

Some digital images are worth more than entire houses. Sounds wild, right? That’s the power of NFTs. They’ve turned pixels into assets, opening a whole new space for creators, investors, and developers. And at the core of this movement? The ERC-721 standard.

If you’re looking to build your own NFT contract, this guide will take you through the process, breaking it down into clear, actionable steps. Whether you’re a developer eager to experiment or an entrepreneur eyeing the NFT space, understanding how to implement ERC-721 is a game-changer.

What is ERC-721?

ERC-721 is a token standard on the Ethereum blockchain. Unlike ERC-20 tokens, which are interchangeable (one ETH is the same as another ETH), ERC-721 tokens are unique. Each NFT has a distinct identity, making it perfect for digital art, collectibles, gaming items, and even real-world assets like property ownership.

At its core, ERC-721 provides a framework for creating these unique tokens, ensuring compatibility across wallets, marketplaces, and applications.

Key Features of ERC-721

• Uniqueness – Each token has a unique identifier, making it different from others in the same contract.
• Ownership – The standard includes functions to track and transfer ownership securely.
• Metadata – NFTs can store extra data, such as images, attributes, or external links.
• Interoperability – Works across various platforms that support ERC-721.

Setting Up Your Development Environment

Before writing any code, make sure your setup is ready. You’ll need:

• Node.js and npm – Used to install dependencies.
• Hardhat or Truffle – Development frameworks for Ethereum smart contracts.
• MetaMask – A crypto wallet for testing transactions.
• Infura or Alchemy – APIs to interact with the Ethereum network.
• Remix IDE (Optional) – A browser-based IDE for Solidity development.

Run the following to set up a Hardhat project:

mkdir my-nft-project  
cd my-nft-project  
npm init -y  
npm install --save-dev hardhat  
npx hardhat

Follow the prompts to create a basic Hardhat project.

Writing Your ERC-721 Contract

Time to write the actual smart contract. We’ll use OpenZeppelin’s ERC-721 implementation to keep things secure and efficient.

Installing OpenZeppelin

npm install @openzeppelin/contracts  

This library saves you from reinventing the wheel. It includes pre-built, audited contracts for ERC-721.

Creating the NFT Contract

Inside your contracts folder, create MyNFT.sol:

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

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

contract MyNFT is ERC721URIStorage, Ownable {
    uint256 private _tokenIdCounter;

    constructor() ERC721("MyNFT", "MNFT") {}

    function mintNFT(address recipient, string memory tokenURI) public onlyOwner {
        _tokenIdCounter++;
        _safeMint(recipient, _tokenIdCounter);
        _setTokenURI(_tokenIdCounter, tokenURI);
    }
}

This contract:

• Extends OpenZeppelin’s ERC721URIStorage for metadata storage.
• Uses Ownable to restrict minting to the contract owner.
• Implements a mintNFT function to create new NFTs.

Deploying the Contract

Configuring Hardhat

Edit hardhat.config.js:

require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: "0.8.0",
  networks: {
    goerli: {
      url: "https://eth-goerli.alchemyapi.io/v2/YOUR_ALCHEMY_KEY",
      accounts: ["YOUR_WALLET_PRIVATE_KEY"],
    },
  },
};

Replace placeholders with your Alchemy API key and wallet private key.

Deploying

Create a deploy.js file inside the scripts folder:

const hre = require("hardhat");

async function main() {
  const MyNFT = await hre.ethers.getContractFactory("MyNFT");
  const myNFT = await MyNFT.deploy();
  await myNFT.deployed();
  console.log("NFT Contract deployed to:", myNFT.address);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Run the deployment:

npx hardhat run scripts/deploy.js --network goerli

Once deployed, you’ll get a contract address.

Minting an NFT

To mint an NFT, use the Hardhat console:

npx hardhat console --network goerli

Then:

const myNFT = await ethers.getContractAt("MyNFT", "YOUR_CONTRACT_ADDRESS");
await myNFT.mintNFT("0xYourWalletAddress", "https://your-metadata-url.com");

Your NFT is now minted and stored on the blockchain!

Understanding NFT Metadata

Metadata is where the magic happens. It contains details about the NFT, such as its name, description, and image. A typical JSON metadata file looks like this:

{
  "name": "My First NFT",
  "description": "This is my first NFT!",
  "image": "https://your-image-url.com/image.png",
  "attributes": [
    { "trait_type": "Background", "value": "Blue" },
    { "trait_type": "Rarity", "value": "Legendary" }
  ]
}

To store metadata, you can:

• Use IPFS via Pinata or NFT.Storage.
• Store it on centralized servers (less ideal but faster).

Adding Royalties

If you want to earn from secondary sales, integrate ERC-2981 for royalties. Update your contract:

import "@openzeppelin/contracts/token/common/ERC2981.sol";

contract MyNFT is ERC721URIStorage, Ownable, ERC2981 {
    function setRoyalty(uint96 feeNumerator) public onlyOwner {
        _setDefaultRoyalty(owner(), feeNumerator);
    }
}

This lets you define a royalty percentage on NFT sales.

Gas Optimization Tips

Ethereum gas fees can be brutal. Here are ways to cut costs:

• Use ERC721A – If minting multiple NFTs, consider ERC721A (Azuki’s optimized implementation).
• Batch minting – Reduce transactions by minting multiple NFTs at once.
• Off-chain metadata – Store metadata off-chain and reference it in the contract.
• Use layer 2 solutions – Polygon, Arbitrum, and Optimism offer cheaper minting.

Final Thoughts

Building an ERC-721 NFT contract isn’t just about writing code. It’s about understanding smart contract security, optimizing for gas fees, and ensuring metadata integrity. The more efficient and secure your contract, the better your NFT project will perform.

By following these steps, you’re not just launching an NFT contract—you’re creating digital assets that can live on the blockchain forever.