创建一个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地址，所以显示的是无聊猿的信息。