关于nft:创建一个ERC721标准的NFT

关上 CHAINPIP 社区，进入利用，创立一个新利用；

将模板代码删除，上传本次测试的合约代码。

这是一个合乎 ERC721 规范的 NFT 合约代码，其中包含了几个罕用的标准接口和合约，上面是个合约的具体信息：
IERC65.sol

pragma solidity ^0.8.0;

/**
 * @dev ERC165 标准接口, 详见
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 合约能够申明反对的接口，供其余合约查看
 *
 */
interface IERC165 {
    /**
     * @dev 如果合约实现了查问的 `interfaceId`，则返回 true
     * 规定详见：https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     *
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

IERC721.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev ERC721 标准接口.
 */
interface IERC721 is IERC165 {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 balanceOf(address owner) external view returns (uint256 balance);

    function ownerOf(uint256 tokenId) external view returns (address owner);

    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;

    function getApproved(uint256 tokenId) external view returns (address operator);

    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

IERC721Receiver.sol

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

// ERC721 接收者接口：合约必须实现这个接口来通过平安转账接管 ERC721
interface IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

IERC721Metadata.sol

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

interface IERC721Metadata {function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function tokenURI(uint256 tokenId) external view returns (string memory);
}

Strings.sol

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.4;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        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 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {if (value == 0) {return "0x00";}
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

Address.sol

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

// Address 库
library Address {
    // 利用 extcodesize 判断一个地址是否为合约地址
    function isContract(address account) internal view returns (bool) {
        uint size;
        assembly {size := extcodesize(account)
        }
        return size > 0;
    }
}

ERC721.sol

// SPDX-License-Identifier: MIT
// by 0xAA
pragma solidity ^0.8.4;

import "./IERC165.sol";
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./String.sol";

contract ERC721 is IERC721, IERC721Metadata{
    using Address for address; // 应用 Address 库，用 isContract 来判断地址是否为合约
    using Strings for uint256; // 应用 String 库，// Token 名称
    string public override name;
    // Token 代号
    string public override symbol;
    // tokenId 到 owner address 的持有人映射
    mapping(uint => address) private _owners;
    // address 到 持仓数量 的持仓量映射
    mapping(address => uint) private _balances;
    // tokenID 到 受权地址 的受权映射
    mapping(uint => address) private _tokenApprovals;
    //  owner 地址。到 operator 地址 的批量受权映射
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * 构造函数，初始化 `name` 和 `symbol` .
     */
    constructor(string memory name_, string memory symbol_) {
        name = name_;
        symbol = symbol_;
    }

    // 实现 IERC165 接口 supportsInterface
    function supportsInterface(bytes4 interfaceId)
        external
        pure
        override
        returns (bool)
    {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC165).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId;
    }

    // 实现 IERC721 的 balanceOf，利用_balances 变量查问 owner 地址的 balance。function balanceOf(address owner) external view override returns (uint) {require(owner != address(0), "owner = zero address");
        return _balances[owner];
    }

    // 实现 IERC721 的 ownerOf，利用_owners 变量查问 tokenId 的 owner。function ownerOf(uint tokenId) public view override returns (address owner) {owner = _owners[tokenId];
        require(owner != address(0), "token doesn't exist");
    }

    // 实现 IERC721 的 isApprovedForAll，利用_operatorApprovals 变量查问 owner 地址是否将所持 NFT 批量受权给了 operator 地址。function isApprovedForAll(address owner, address operator)
        external
        view
        override
        returns (bool)
    {return _operatorApprovals[owner][operator];
    }

    // 实现 IERC721 的 setApprovalForAll，将持有代币全副受权给 operator 地址。调用_setApprovalForAll 函数。function setApprovalForAll(address operator, bool approved) external override {_operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    // 实现 IERC721 的 getApproved，利用_tokenApprovals 变量查问 tokenId 的受权地址。function getApproved(uint tokenId) external view override returns (address) {require(_owners[tokenId] != address(0), "token doesn't exist");
        return _tokenApprovals[tokenId];
    }
     
    // 受权函数。通过调整_tokenApprovals 来，受权 to 地址操作 tokenId，同时开释 Approval 事件。function _approve(
        address owner,
        address to,
        uint tokenId
    ) private {_tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    // 实现 IERC721 的 approve，将 tokenId 受权给 to 地址。条件：to 不是 owner，且 msg.sender 是 owner 或受权地址。调用_approve 函数。function approve(address to, uint tokenId) external override {address owner = _owners[tokenId];
        require(msg.sender == owner || _operatorApprovals[owner][msg.sender],
            "not owner nor approved for all"
        );
        _approve(owner, to, tokenId);
    }

    // 查问 spender 地址是否被能够应用 tokenId（他是 owner 或被受权地址）。function _isApprovedOrOwner(
        address owner,
        address spender,
        uint tokenId
    ) private view returns (bool) {
        return (spender == owner ||
            _tokenApprovals[tokenId] == spender ||
            _operatorApprovals[owner][spender]);
    }

    /*
     * 转账函数。通过调整_balances 和_owner 变量将 tokenId 从 from 转账给 to，同时开释 Tranfer 事件。* 条件:
     * 1. tokenId 被 from 领有
     * 2. to 不是 0 地址
     */
    function _transfer(
        address owner,
        address from,
        address to,
        uint tokenId
    ) private {require(from == owner, "not owner");
        require(to != address(0), "transfer to the zero address");

        _approve(owner, address(0), tokenId);

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

        emit Transfer(from, to, tokenId);
    }
    
    // 实现 IERC721 的 transferFrom，非平安转账，不倡议应用。调用_transfer 函数
    function transferFrom(
        address from,
        address to,
        uint tokenId
    ) external override {address owner = ownerOf(tokenId);
        require(_isApprovedOrOwner(owner, msg.sender, tokenId),
            "not owner nor approved"
        );
        _transfer(owner, from, to, tokenId);
    }

    /**
     * 平安转账，平安地将 tokenId 代币从 from 转移到 to，会查看合约接收者是否理解 ERC721 协定，以避免代币被永恒锁定。调用了_transfer 函数和_checkOnERC721Received 函数。条件：* from 不能是 0 地址.
     * to 不能是 0 地址.
     * tokenId 代币必须存在，并且被 from 领有.
     * 如果 to 是智能合约, 他必须反对 IERC721Receiver-onERC721Received.
     */
    function _safeTransfer(
        address owner,
        address from,
        address to,
        uint tokenId,
        bytes memory _data
    ) private {_transfer(owner, from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "not ERC721Receiver");
    }

    /**
     * 实现 IERC721 的 safeTransferFrom，平安转账，调用了_safeTransfer 函数。*/
    function safeTransferFrom(
        address from,
        address to,
        uint tokenId,
        bytes memory _data
    ) public override {address owner = ownerOf(tokenId);
        require(_isApprovedOrOwner(owner, msg.sender, tokenId),
            "not owner nor approved"
        );
        _safeTransfer(owner, from, to, tokenId, _data);
    }

    // safeTransferFrom 重载函数
    function safeTransferFrom(
        address from,
        address to,
        uint tokenId
    ) external override {safeTransferFrom(from, to, tokenId, "");
    }

    /** 
     * 铸造函数。通过调整_balances 和_owners 变量来铸造 tokenId 并转账给 to，同时开释 Tranfer 事件。铸造函数。通过调整_balances 和_owners 变量来铸造 tokenId 并转账给 to，同时开释 Tranfer 事件。* 这个 mint 函数所有人都能调用，理论应用须要开发人员重写，加上一些条件。* 条件:
     * 1. tokenId 尚不存在。* 2. to 不是 0 地址.
     */
    function _mint(address to, uint tokenId) internal virtual {require(to != address(0), "mint to zero address");
        require(_owners[tokenId] == address(0), "token already minted");

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

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

    // 销毁函数，通过调整_balances 和_owners 变量来销毁 tokenId，同时开释 Tranfer 事件。条件：tokenId 存在。function _burn(uint tokenId) internal virtual {address owner = ownerOf(tokenId);
        require(msg.sender == owner, "not owner of token");

        _approve(owner, address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

    // _checkOnERC721Received：函数，用于在 to 为合约的时候调用 IERC721Receiver-onERC721Received, 以防 tokenId 被不小心转入黑洞。function _checkOnERC721Received(
        address from,
        address to,
        uint tokenId,
        bytes memory _data
    ) private returns (bool) {if (to.isContract()) {
            return
                IERC721Receiver(to).onERC721Received(
                    msg.sender,
                    from,
                    tokenId,
                    _data
                ) == IERC721Receiver.onERC721Received.selector;
        } else {return true;}
    }

    /**
     * 实现 IERC721Metadata 的 tokenURI 函数，查问 metadata。*/
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {require(_owners[tokenId] != address(0), "Token Not Exist");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * 计算 {tokenURI} 的 BaseURI，tokenURI 就是把 baseURI 和 tokenId 拼接在一起，须要开发重写。* BAYC 的 baseURI 为 ipfs://QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/ 
     */
    function _baseURI() internal view virtual returns (string memory) {return "";}
}

编译、部署合约，设置 NFT 名称为 HHTest，符号为 HH。

合约部署胜利后，进入 ABI 操作页面，开始测试合约的 mint 函数，测试铸造一个 NFT。

铸造实现后应用合约地址在 opensea 的测试链版中查问，能够发现咱们刚刚铸造的 NFT 能够在其中查问进去，因为合约用的是无聊猿的 tokenURI 地址，所以显示的是无聊猿的信息。