ERC-721 — Non-Fungible Token

Back to Token Standards

ERC-721: Non-Fungible Token

ERC-721 defines NFTs — unique on-chain assets identified by uint256 tokenId. It powers collectibles, gaming items, real-world asset titles, and identity primitives.

Required Interface

Method	Purpose
balanceOf(address)	NFT count owned
ownerOf(uint256)	Owner of a token
transferFrom(...) / safeTransferFrom(...)	Transfer ownership
approve / setApprovalForAll / getApproved / isApprovedForAll	Approval surface

Neo Equivalent: NEP-11

NEP-11 covers the same ground with three concrete improvements: bytes32-style token IDs (no integer collisions; can use content hashes), required tokensOf(owner) iterator (enumeration is part of the standard), and required properties(tokenId) (on-chain metadata as a serialised map, replacing the off-chain tokenURI JSON that's famously fragile).

NEP-11 also natively supports divisible NFTs — when decimals() > 0, the same standard handles fractionalised NFTs.

Live on Neo TestNet

Both implementations deployed and tested on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash	Deploy Tx
Solidity (neo-solc)	NbTK8px52xHxJ5zSJvVFqBujZ5eQEV4dYt	0x48b5f8f579810b402fed660844145fed406f77aa	0x2bac122c…6674
Neo C# (nccs)	NbuB1V5es6YBtPfVrW4R9bDtxDieuZoK38	0x15c664d51340a102490dbf5dec5647f541775baf	(re-used)

Verified: symbol, decimals, mint, balanceOf. Source pairs and runner under docs/standards-mirror/deployments/erc-721/.

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

contract ERC721 {
    string public name   = "Demo NFT";
    string public symbol = "DNFT";

    mapping(uint256 => address) private _owner;
    mapping(address => uint256) private _balance;
    mapping(uint256 => address) private _approved;
    mapping(address => mapping(address => bool)) private _operator;

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

    function ownerOf(uint256 tokenId) public view returns (address) {
        address o = _owner[tokenId];
        require(o != address(0), "ERC721: nonexistent token");
        return o;
    }

    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0), "ERC721: zero owner");
        return _balance[owner];
    }

    function approve(address to, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(msg.sender == owner || _operator[owner][msg.sender], "not authorized");
        _approved[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    function setApprovalForAll(address operator, bool approved) public {
        _operator[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isAuthorized(msg.sender, tokenId), "not authorized");
        require(ownerOf(tokenId) == from,           "wrong from");
        require(to != address(0),                   "zero to");
        delete _approved[tokenId];
        _balance[from] -= 1;
        _balance[to]   += 1;
        _owner[tokenId] = to;
        emit Transfer(from, to, tokenId);
    }

    function _isAuthorized(address spender, uint256 tokenId) internal view returns (bool) {
        address owner = ownerOf(tokenId);
        return spender == owner
            || _approved[tokenId] == spender
            || _operator[owner][spender];
    }
}

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("DemoNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class DemoNFT : SmartContract
{
    private const byte Prefix_TokenOwner = 0x01;
    private const byte Prefix_OwnerToken = 0x02;
    private const byte Prefix_Properties = 0x03;
    private const byte Prefix_TotalSupply = 0x04;

    [DisplayName("Transfer")]
    public static event Action<UInt160, UInt160, BigInteger, ByteString> OnTransfer;

    [Safe]
    public static string Symbol()   => "DNFT";
    public static byte   Decimals() => 0;

    public static BigInteger TotalSupply()
        => (BigInteger)(Storage.Get(Storage.CurrentContext, new byte[] { Prefix_TotalSupply }) ?? ByteString.Empty);

    public static UInt160 OwnerOf(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_TokenOwner }.Concat(tokenId));
        if (raw == null) throw new Exception("nonexistent token");
        return (UInt160)raw;
    }

    public static BigInteger BalanceOf(UInt160 owner)
    {
        var iter = Storage.Find(Storage.CurrentContext,
                                new byte[] { Prefix_OwnerToken }.Concat(owner),
                                FindOptions.KeysOnly | FindOptions.RemovePrefix);
        BigInteger n = 0;
        while (iter.Next()) n++;
        return n;
    }

    public static Iterator TokensOf(UInt160 owner)
        => Storage.Find(Storage.CurrentContext,
                        new byte[] { Prefix_OwnerToken }.Concat(owner),
                        FindOptions.KeysOnly | FindOptions.RemovePrefix);

    public static Map<string, object> Properties(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext,
                              new byte[] { Prefix_Properties }.Concat(tokenId));
        if (raw == null) throw new Exception("nonexistent token");
        return (Map<string, object>)StdLib.Deserialize(raw);
    }

    public static bool Transfer(UInt160 to, ByteString tokenId, object data)
    {
        if (!to.IsValid) throw new Exception("invalid recipient");
        var from = OwnerOf(tokenId);
        if (!Runtime.CheckWitness(from)) throw new Exception("no authorization");

        Storage.Delete(Storage.CurrentContext,
                       new byte[] { Prefix_OwnerToken }.Concat(from).Concat(tokenId));
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_OwnerToken }.Concat(to).Concat(tokenId), 1);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_TokenOwner }.Concat(tokenId), to);

        OnTransfer(from, to, 1, tokenId);
        if (ContractManagement.GetContract(to) != null)
            Contract.Call(to, "onNEP11Payment", CallFlags.All,
                new object[] { from, 1, tokenId, data });
        return true;
    }

    public static void Mint(UInt160 to, ByteString tokenId, Map<string, object> props)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        if (Storage.Get(Storage.CurrentContext,
                        new byte[] { Prefix_TokenOwner }.Concat(tokenId)) != null)
            throw new Exception("token exists");
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_TokenOwner }.Concat(tokenId), to);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_OwnerToken }.Concat(to).Concat(tokenId), 1);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Properties }.Concat(tokenId), StdLib.Serialize(props));

        var supply = TotalSupply() + 1;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_TotalSupply }, supply);
        OnTransfer(UInt160.Zero, to, 1, tokenId);
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}