NFTs (Non-Fungible Tokens) — Explained with Examples

// MyNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

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

contract MyNFT is ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;
    uint256 public mintPrice = 0.01 ether;
    uint256 public maxSupply = 100;
    uint256 public totalMinted;

    event NFTMinted(address indexed owner, uint256 indexed tokenId, string tokenURI);

    constructor() ERC721("DodaTech Collection", "DTECH") {
        _nextTokenId = 1;
    }

    function mintNFT(string memory tokenURI) public payable returns (uint256) {
        require(totalMinted < maxSupply, "Max supply reached");
        require(msg.value >= mintPrice, "Insufficient payment");

        uint256 tokenId = _nextTokenId;
        _nextTokenId++;
        totalMinted++;

        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, tokenURI);

        emit NFTMinted(msg.sender, tokenId, tokenURI);
        return tokenId;
    }

    function withdrawFunds() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }

    function updateMintPrice(uint256 newPrice) external onlyOwner {
        mintPrice = newPrice;
    }
}

{
  "name": "DodaTech Genesis #1",
  "description": "The first NFT from DodaTech's collection. Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.",
  "image": "ipfs://QmXp4aBqy8z9K3x5C7v2dN6rL9mW1jR4tV8sG3hK5fA2pE",
  "attributes": [
    {"trait_type": "Background", "value": "Cyber Blue"},
    {"trait_type": "Rarity", "value": "Legendary"},
    {"trait_type": "Year", "value": "2026"},
    {"trait_type": "Artist", "value": "DodaTech Team"}
  ]
}

// hardhat.config.js
require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: "0.8.19",
  networks: {
    sepolia: {
      url: `https://sepolia.infura.io/v3/YOUR_PROJECT_ID`,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  console.log("Deploying MyNFT...");

  const MyNFT = await hre.ethers.getContractFactory("MyNFT");
  const contract = await MyNFT.deploy();

  await contract.deployed();
  console.log("MyNFT deployed to:", contract.address);

  // Verify on Etherscan
  if (hre.network.name !== "hardhat") {
    console.log("Waiting for block confirmations...");
    await contract.deployTransaction.wait(5);
    await hre.run("verify:verify", {
      address: contract.address,
      constructorArguments: [],
    });
    console.log("Contract verified on Etherscan");
  }
}

main().catch(console.error);

# Deploy to Sepolia testnet
npx hardhat run scripts/deploy.js --network sepolia

# Expected output:
# Deploying MyNFT...
# MyNFT deployed to: 0x1234...5678
# Contract verified on Etherscan

// scripts/mint.js
const hre = require("hardhat");

async function main() {
  const contractAddress = "0x1234...5678"; // Your deployed contract
  const MyNFT = await hre.ethers.getContractFactory("MyNFT");
  const contract = MyNFT.attach(contractAddress);

  const tokenURI = "ipfs://QmXp4aBqy8z9K3x5C7v2dN6rL9mW1jR4tV8sG3hK5fA2pE";

  const tx = await contract.mintNFT(tokenURI, {
    value: hre.ethers.utils.parseEther("0.01")
  });
  await tx.wait();

  console.log(`NFT minted! Transaction: ${tx.hash}`);

  // Check token owner
  const owner = await contract.ownerOf(1);
  console.log(`Token #1 owned by: ${owner}`);

  // Check token URI
  const uri = await contract.tokenURI(1);
  console.log(`Token #1 URI: ${uri}`);
}

main().catch(console.error);

// Adding royalties to your NFT contract
import "@openzeppelin/contracts/interfaces/IERC2981.sol";

contract RoyaltyNFT is ERC721URIStorage, Ownable, IERC2981 {
    uint256 private _royaltyPercent = 500; // 5% (500 basis points)

    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        override
        returns (address receiver, uint256 royaltyAmount)
    {
        return (owner(), salePrice * _royaltyPercent / 10000);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721URIStorage, IERC165)
        returns (bool)
    {
        return interfaceId == type(IERC2981).interfaceId
            || super.supportsInterface(interfaceId);
    }
}

// Gas-optimized batch minting
contract BatchMintNFT is ERC721 {
    uint256 private _nextTokenId;
    string private _baseTokenURI;

    // Batch mint — much cheaper than individual mints
    function batchMint(address to, uint256 quantity) external {
        for (uint256 i = 0; i < quantity; i++) {
            _safeMint(to, _nextTokenId + i);
        }
        _nextTokenId += quantity;
    }

    // Use base URI instead of per-token URI to save gas
    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }

    // Lazy minting — only update state when the token transfers
    mapping(uint256 => address) private _owners;
    function ownerOf(uint256 tokenId) public view override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "Nonexistent token");
        return owner;
    }
}