ERC-721：NFT 如何證明數位所有權

// The ERC-721 core interface (EIP-721), Solidity ^0.8
interface IERC721 {
    // Events — the only on-chain trail of who got what
    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);

    // Reads
    function balanceOf(address owner) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function getApproved(uint256 tokenId) external view returns (address);
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    // Writes
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function setApprovalForAll(address operator, bool approved) external;
}

contract MiniERC721 {
    mapping(uint256 => address) private _owners;    // tokenId  => owner
    mapping(address => uint256) private _balances;  // owner    => count

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

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

    // Create token `tokenId` and assign it to `to`.
    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0), "ERC721: mint to zero address");
        require(_owners[tokenId] == address(0), "ERC721: already minted");
        _balances[to]   += 1;
        _owners[tokenId] = to;
        emit Transfer(address(0), to, tokenId);   // mint = Transfer FROM the zero address
    }

    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
}

mapping(uint256 => address) private _tokenApprovals;             // tokenId => approved address
mapping(address => mapping(address => bool)) private _operatorApprovals; // owner => operator => ok

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

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

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

// The gate every transfer must pass: owner, single-token approvee, or operator.
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
    address owner = ownerOf(tokenId);
    return (spender == owner ||
            _tokenApprovals[tokenId] == spender ||
            isApprovedForAll(owner, spender));
}

function transferFrom(address from, address to, uint256 tokenId) public {
    require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: not owner nor approved");
    require(ownerOf(tokenId) == from, "ERC721: wrong from");
    require(to != address(0), "ERC721: transfer to zero address");
    delete _tokenApprovals[tokenId];   // a single-token approval is consumed by the transfer
    _balances[from] -= 1;
    _balances[to]   += 1;
    _owners[tokenId] = to;
    emit Transfer(from, to, tokenId);
}

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

// The magic value: bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")) == 0x150b7a02
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data)
    private returns (bool)
{
    if (to.code.length == 0) return true;   // a plain wallet (EOA) has no code — nothing to ask
    try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
        return retval == IERC721Receiver.onERC721Received.selector;  // must echo the magic value
    } catch {
        revert("ERC721: transfer to non-ERC721Receiver");
    }
}

function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
    transferFrom(from, to, tokenId);                                 // do the move first...
    require(_checkOnERC721Received(from, to, tokenId, data), "unsafe recipient");
}

// On-chain: most collections store only a base URI and append the id.
string private _baseURI = "ipfs://bafybeih.../";

function tokenURI(uint256 tokenId) public view returns (string memory) {
    require(_owners[tokenId] != address(0), "ERC721: nonexistent token");
    return string.concat(_baseURI, Strings.toString(tokenId));   // e.g. ipfs://bafy.../42
}

// Off-chain, at that URI, lives the actual metadata JSON:
// {
//   "name": "Voyager #42",
//   "description": "A starship from the Voyager collection.",
//   "image": "ipfs://bafkrei.../42.png",
//   "attributes": [
//     { "trait_type": "Hull",  "value": "Titanium" },
//     { "trait_type": "Speed", "value": 88 }
//   ]
// }