ERC-7561: 简化的 NFT，简化的 ERC-721

pragma solidity ^0.8.20;

/**
 * @title ERC7561 简单 NFT 接口
 * @dev 查看 https://ercs.ethereum.org/ERCS/erc-7561
 */
interface IERC7561 {
    /**
     * @notice 用于通知转移 NFT。
     * @param from 来源地址
     * @param to 接收地址
     * @param tokenId 交易 token id
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /**
     * @notice 统计分配给所有者的所有 NFT
     * @param owner 所有者的地址
     * @return `owner` 拥有的 NFT 数量，可能为零
     */
    function balanceOf(address owner) 
        external
        view
        returns (uint256);

    /**
     * @notice 查找 NFT 的所有者
     * @param tokenId NFT 的标识符
     * @return NFT 所有者的地址
     */
    function ownerOf(uint256 tokenId) 
        external  
        view
        returns (address);
	  

    /**
     * @notice 转移 NFT 的所有权
     * @param from 来源地址
     * @param to 目的地址
     * @param tokenId 要转移的 NFT
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

}

pragma solidity ^0.8.20;

import "./IERC7561.sol";
import "../../math/SafeMath.sol";

/**
 * @title 标准 ERC7561 NFT
 * @dev 注意：此接口的 ERC-165 标识符为 0xc1b31357
 * @dev 基本标准 NFT 的实现。
 */
contract ERC7561 is IERC7561 {

    // Token 名称
    string private _name;

    // Token 符号
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    uint256 private _totalSupply;

    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

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

    function ownerOf(uint256 tokenId) public view  returns (address) {
        return _requireOwned(tokenId);
    }


    function transferFrom(address from, address to, uint256 tokenId) public  {

        require(from == msg.sender);

        require (to != address(0) );

        address previousOwner = _update(to, tokenId);

        require(previousOwner == from);
    }


    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0));
            
        return owner;
    }

    function _update(address to, uint256 tokenId) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        
        // 执行更新
        if (from != address(0)) {         

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

}