ERC-721 Tokens (NFT)

// Globally unique NFT identification
(contract address, tokenId) = unique NFT

// Inside ERC-721 contract
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;

// Example:
// _owners[1] = 0x1234...  ← Alice owns NFT #1
// _owners[2] = 0x5678...  ← Bob owns NFT #2
// _balances[alice] = 2    ← Alice owns 2 NFTs total

// Query NFT owner
// Returns the owner address of a specific token ID
function ownerOf(uint256 tokenId) public view returns (address)

// Returns the number of NFTs owned by a specific address
function balanceOf(address owner) public view returns (uint256)

// Returns the token's metadata URI
// Location of JSON file containing image, name, description
function tokenURI(uint256 tokenId) public view returns (string)

// Query approved address
// Check which address can transfer a specific NFT
function getApproved(uint256 tokenId) public view returns (address)

// Check if operator has permission to manage all of owner's NFTs
function isApprovedForAll(address owner, address operator) public view returns (bool)

// Transfer NFT from 'from' to 'to'
// The most basic transfer method
function transferFrom(address from, address to, uint256 tokenId) public

// Same as transferFrom but checks safety if 'to' is a contract
// Prevents NFTs from being locked in contracts
function safeTransferFrom(address from, address to, uint256 tokenId) public

// Approve 'approved' address to transfer a specific NFT
function approve(address approved, uint256 tokenId) public

// Approve/revoke operator to manage all of owner's NFTs
// Commonly used by marketplaces
function setApprovalForAll(address operator, bool approved) public

// Emitted whenever an NFT is transferred
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)

// Emitted when NFT usage is approved
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)

// Emitted when full approval is set/revoked
event ApprovalForAll(address indexed owner, address indexed operator, bool approved)

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

contract SimpleNFT {
    // NFT info
    string public name = "My NFT";
    string public symbol = "MNFT";

    // Owner of each token ID
    mapping(uint256 => address) private _owners;

    // Number of NFTs owned by each address
    mapping(address => uint256) private _balances;

    // Approved address for each token ID
    mapping(uint256 => address) private _tokenApprovals;

    // Owner grants operator permission to manage all NFTs
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // Events
    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);

    // Mint NFT
    function mint(address to, uint256 tokenId) public {
        require(to != address(0), "Invalid mint target");
        require(_owners[tokenId] == address(0), "Token already exists");

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    // Query owner
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "Token does not exist");
        return owner;
    }

    // Query balance
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0), "Invalid address");
        return _balances[owner];
    }

    // Transfer NFT
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "No transfer permission");
        require(ownerOf(tokenId) == from, "Owner mismatch");
        require(to != address(0), "Invalid recipient address");

        // Clear approval
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    // Approve
    function approve(address approved, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(msg.sender == owner, "Only owner can approve");
        require(approved != owner, "Cannot approve to owner");

        _approve(approved, tokenId);
    }

    // Approve all
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "Cannot approve to self");
        _operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    // Query approval
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_owners[tokenId] != address(0), "Token does not exist");
        return _tokenApprovals[tokenId];
    }

    // Query approval for all
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // Internal functions
    function _approve(address approved, uint256 tokenId) private {
        _tokenApprovals[tokenId] = approved;
        emit Approval(ownerOf(tokenId), approved, tokenId);
    }

    function _isApprovedOrOwner(address spender, uint256 tokenId) private view returns (bool) {
        address owner = ownerOf(tokenId);
        return (spender == owner ||
                getApproved(tokenId) == spender ||
                isApprovedForAll(owner, spender));
    }
}

// Alice transfers NFT #5 to Bob
nft.transferFrom(aliceAddress, bobAddress, 5);

// What happens inside the contract:
require(_isApprovedOrOwner(msg.sender, 5), "No transfer permission");
_balances[alice] -= 1;  // Alice: 3 → 2
_balances[bob] += 1;    // Bob: 1 → 2
_owners[5] = bob;       // Change owner of NFT #5 to Bob
emit Transfer(alice, bob, 5);

// Alice grants OpenSea permission to transfer only NFT #5
nft.approve(openSeaAddress, 5);

// Alice grants OpenSea permission to transfer all her NFTs
nft.setApprovalForAll(openSeaAddress, true);

// Alice approves OpenSea to transfer NFT #5
nft.approve(openSeaAddress, 5);

// Inside contract:
_tokenApprovals[5] = openSea;
emit Approval(alice, openSea, 5);

// Or approve all NFTs
nft.setApprovalForAll(openSeaAddress, true);

// Inside contract:
_operatorApprovals[alice][openSea] = true;
emit ApprovalForAll(alice, openSea, true);

function tokenURI(uint256 tokenId) public view returns (string) {
    return string(abi.encodePacked(baseURI, tokenId.toString(), ".json"));
}

// Example:
// tokenURI(1) => "https://api.example.com/metadata/1.json"
// tokenURI(2) => "https://api.example.com/metadata/2.json"

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

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

    // Returns baseURI (used for tokenURI generation)
    // tokenURI(1) => "https://api.example.com/metadata/1"
    // tokenURI(2) => "https://api.example.com/metadata/2"
    function _baseURI() internal view override returns (string memory) {
        return "https://api.example.com/metadata/";
    }
}