EIP-721ERC代币标准Final（2018-01-24）

非同质化代币（NFT）标准

每个 tokenId 唯一、不可互换的所有权标准。核心是 ownerOf + 安全转账 + 授权与元数据扩展。

适用链：全部 EVM 链 + 各 L2

为什么重要：NFT 的「唯一性」不是靠图片，而是靠链上 tokenId 到 owner 的映射。看懂 ERC-721 就能一眼分辨「真上链的藏品」和「只是一张指向服务器的图片链接」。

函数签名与选择器

选择器是签名的 keccak256 前 4 字节；事件则是完整的 32 字节 topic0。点一下即可复制。

签名 / 字段	选择器 / topic0	说明
balanceOf(address)		该地址持有的 NFT 数量，不是 tokenId 列表。
ownerOf(uint256)		tokenId 的持有人。不存在的 tokenId 必须 revert。
transferFrom(address,address,uint256)		直接转移，不检查接收方是否支持（转进合约可能永久锁死）。
safeTransferFrom(address,address,uint256)		推荐用法：接收方是合约时会调用 onERC721Received 检查。
safeTransferFrom(address,address,uint256,bytes)		带额外 data，用于传递业务上下文。
approve(address,uint256)		授权单个 tokenId 给某人。
setApprovalForAll(address,bool)		授权全部藏品给某操作者，NFT 市场靠它挂单，也是被盗重灾区。
getApproved(uint256)		查询单个 tokenId 的授权对象。
isApprovedForAll(address,address)		查询操作者是否被全局授权。
supportInterface(bytes4)		EIP-165：声明自己实现了 ERC-721 与 Metadata 扩展。
tokenURI(uint256)		Metadata 扩展：返回元数据 JSON 的 URI。
event Transfer(address,address,uint256)事件		与 ERC-20 同名但语义不同：第三个参数是 tokenId。

代码模板

最小实现（含 safeTransferFrom 接收检查）

最小实现（含 safeTransferFrom 接收检查）Solidity

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

interface IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

contract MinimalERC721 {
    string public name = "Academy Pass";
    string public symbol = "PASS";

    uint256 public totalSupply;
    string private _baseURI = "ipfs://";

    mapping(uint256 => address) private _owners;
    mapping(address => uint256) private _balances;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;

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

    error NotOwner();
    error ZeroAddress();
    error NotAuthorized();
    error NonexistentToken();
    error UnsafeRecipient();

    modifier onlyExisting(uint256 tokenId) {
        if (_owners[tokenId] == address(0)) revert NonexistentToken();
        _;
    }

    function balanceOf(address owner) external view returns (uint256) {
        if (owner == address(0)) revert ZeroAddress();
        return _balances[owner];
    }

    function ownerOf(uint256 tokenId) public view onlyExisting(tokenId) returns (address) {
        return _owners[tokenId];
    }

    function getApproved(uint256 tokenId) external view onlyExisting(tokenId) returns (address) {
        return _tokenApprovals[tokenId];
    }

    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    function approve(address to, uint256 tokenId) external {
        address owner = ownerOf(tokenId);
        if (msg.sender != owner && !_operatorApprovals[owner][msg.sender]) revert NotAuthorized();

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

    function transferFrom(address from, address to, uint256 tokenId) public {
        if (!_isApprovedOrOwner(msg.sender, tokenId)) revert NotAuthorized();
        if (ownerOf(tokenId) != from) revert NotOwner();
        if (to == address(0)) revert ZeroAddress();

        // 清空授权，防止旧授权在转移后被复用（这是必需的安全步骤）
        delete _tokenApprovals[tokenId];

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

        emit Transfer(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) external {
        safeTransferFrom(from, to, tokenId, "");
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
        transferFrom(from, to, tokenId);
        if (to.code.length > 0) {
            if (
                IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data)
                    != IERC721Receiver.onERC721Received.selector
            ) revert UnsafeRecipient();
        }
    }

    function tokenURI(uint256 tokenId) external view onlyExisting(tokenId) returns (string memory) {
        return string.concat(_baseURI, _toString(tokenId));
    }

    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
        // 0x80ac58cd = ERC-721, 0x5b5e139f = Metadata 扩展, 0x01ffc9a7 = EIP-165
        return interfaceId == 0x80ac58cd || interfaceId == 0x5b5e139f || interfaceId == 0x01ffc9a7;
    }

    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        address owner = ownerOf(tokenId);
        return spender == owner
            || _tokenApprovals[tokenId] == spender
            || _operatorApprovals[owner][spender];
    }

    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) revert ZeroAddress();
        if (_owners[tokenId] != address(0)) revert NonexistentToken();

        unchecked {
            totalSupply += 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

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

    function _toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) return "0";
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + (value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

转移时 delete _tokenApprovals 是必需的安全动作。漏掉它会让上一任 owner 给的授权在换手后依然有效。

元数据 JSON 的结构

元数据 JSON 的结构JSON

{
  "name": "Academy Pass #001",
  "description": "Web3 学院学习凭证，完成开发者路径后铸造。",
  "image": "ipfs://bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi/1.png",
  "animation_url": "ipfs://bafy.../1.mp4",
  "external_url": "https://web3academy.example/pass/1",
  "attributes": [
    { "trait_type": "Tier", "value": "Gold" },
    { "trait_type": "Path", "value": "Developer" },
    { "trait_type": "CompletedAt", "value": 1767225600, "display_type": "date" },
    { "trait_type": "Level", "value": 7, "display_type": "number", "max_value": 10 }
  ]
}

image 用 ipfs:// 而不是 https://，是区分「不可篡改」与「随时能换图」的关键信号。

实现与使用时的常见陷阱

✕setApprovalForAll 一旦授权，对方能搬走你该系列的全部藏品。挂单完成后及时撤销，或使用支持「限价单委托」的市场。
✕tokenURI 指向中心化服务器时，项目方随时能换掉图片，链上只留一个 tokenId。
✕transferFrom 不检查接收方，转进不支持 ERC-721 的合约会永久锁死；一律优先用 safeTransferFrom。
✕实现 Metadata 扩展时 tokenURI 必须对不存在的 tokenId revert，返回空字符串会让市场显示成「无元数据」。
✕supportsInterface 要返回 true 的 id 必须与实际实现一致，否则部分市场会拒绝展示。

非同质化代币（NFT）标准

函数签名与选择器

代码模板

实现与使用时的常见陷阱

相关标准