How to write a smart contract for an NFT?

A smart contract for NFTs automates ownership and transfers on blockchains like Ethereum, using standards like ERC-721 or ERC-1155.

Jul 10, 2025 at 07:28 pm

Understanding the Basics of Smart Contracts

Before diving into writing a smart contract for an NFT, it's essential to understand what a smart contract is. A smart contract is a self-executing contract with the terms of the agreement directly written into code. It automatically executes actions when predefined conditions are met. In the context of NFTs (Non-Fungible Tokens), smart contracts are used to define ownership, transferability, and other unique properties of digital assets.

Smart contracts for NFTs typically run on blockchain platforms like Ethereum, Binance Smart Chain, or Polygon. The most common standard for NFTs on Ethereum is ERC-721, while ERC-1155 supports both fungible and non-fungible tokens in a single contract. These standards provide a framework that ensures compatibility across different platforms and wallets.

Choosing the Right Blockchain Platform

The first step in creating an NFT smart contract is selecting the appropriate blockchain platform. Ethereum remains the most popular due to its mature ecosystem and widespread adoption. However, alternatives like Binance Smart Chain and Polygon offer lower gas fees and faster transaction times.

Each platform has its own set of tools and standards. For example, Solidity is the primary programming language used for writing smart contracts on Ethereum. If you're using a different blockchain, such as Solana or Tezos, you may need to use alternative languages like Rust or Ligo.

It's also important to consider gas fees, network congestion, and developer support before making your choice. Developers should be familiar with the selected platform’s documentation and development environment to ensure smooth deployment.

Setting Up the Development Environment

To write and deploy a smart contract for an NFT, you’ll need a proper development setup. This includes installing tools like:

• Node.js: Required for running JavaScript-based development tools.
• Truffle Suite: A popular development framework for Ethereum smart contracts.
• Hardhat: An alternative to Truffle, offering better debugging capabilities.
• Remix IDE: A browser-based IDE for quick testing and deployment of small contracts.
• MetaMask: A cryptocurrency wallet used to interact with the Ethereum network.

Once these tools are installed, create a new project directory and initialize it using npm init -y. Install necessary dependencies like @openzeppelin/contracts, which provides pre-audited implementations of ERC-721 and ERC-1155 standards.

Writing the Smart Contract Code

Using OpenZeppelin’s ERC-721 implementation can significantly simplify the process. Start by importing the required libraries:

pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MyNFT is ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;

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

function mintNFT(address recipient, string memory tokenURI) public returns (uint256) {
    _tokenIds.increment();
    uint256 newItemId = _tokenIds.current();
    _mint(recipient, newItemId);
    _setTokenURI(newItemId, tokenURI);
    return newItemId;
}
}

This basic contract allows users to mint NFTs with a specified token URI, which usually points to metadata stored on IPFS or another decentralized storage solution. Make sure to replace “MyNFT” and “MNFT” with your desired token name and symbol.

Compile the contract using solc or your preferred compiler. Check for any syntax errors or warnings before proceeding to deployment.

Deploying the Smart Contract

After successfully compiling your contract, the next step is deployment. You can deploy to a testnet like Rinkeby or Goerli before moving to the mainnet. Use Hardhat or Truffle to automate this process.

Create a deployment script inside the scripts folder:

async function main() {
const MyNFT = await ethers.getContractFactory("MyNFT");
const myNFT = await MyNFT.deploy();

await myNFT.deployed();

console.log("Contract deployed to:", myNFT.address);
}
main()
.then(() => process.exit(0))
.catch((error) => {
    console.error(error);
    process.exit(1);
});
Run the deployment command using npx hardhat run scripts/deploy.js --network rinkeby. Ensure you have sufficient ETH in your MetaMask wallet to cover gas fees. Once deployed, verify the contract on Etherscan to make it publicly accessible and auditable.
Frequently Asked Questions (FAQ)
What is the difference between ERC-721 and ERC-1155?

ERC-721 is designed for unique, non-fungible tokens where each token is distinct and indivisible. ERC-1155, on the other hand, allows for both fungible and non-fungible tokens within the same contract, enabling more efficient batch transfers and reduced gas costs.

Do I need to write all the code from scratch?

No, developers often utilize OpenZeppelin’s library to import pre-written, secure, and audited code for common functionalities like ownership, minting, and token URI handling. This reduces the risk of vulnerabilities and speeds up development.

Can I change the metadata after minting?

Yes, but only if the smart contract includes a function to update the token URI. Be cautious—some marketplaces may not reflect changes unless explicitly re-indexed. Always plan metadata updates carefully during contract design.

How much does it cost to deploy an NFT smart contract?

Deployment costs depend on network congestion, contract size, and gas prices. On Ethereum, it can range from $50 to several hundred dollars. Using layer 2 solutions like Polygon can significantly reduce these costs.