solidity实现ERC721代币标准发布NFT

1、非同质化货币(NFT)- 维基百科

非同质化代币(英语:Non-Fungible Token,简称:NFT),是一种众筹扶持项目方的方式,也是区块链(数位账本)上的一种数据单位,每个代币可以代表一个独特的数字资料,作为虚拟商品所有权的电子认证或证书。由于其不能互换的特性,非同质化代币可以代表数字资产,如画作、艺术品、声音、影片、游戏中的项目或其他形式的创意作品。虽然作品本身是可以无限复制的,但这些代表它们的代币在其底层区块链上能被完整追踪,故能为买家提供所有权证明。诸如以太币、比特币等加密货币都有自己的代币标准以定义对NFT的使用。

2、IERC165

ERC165 是一个非常简单的以太坊标准,主要用于检测该合约是否支持查询的接口。调用者只需要传入想要检测的接口的ID(如ERC-165的ID是0x01ffc9a7),该函数以布尔值的方式(true支持,false不支持)告诉调用者该合约是否实现了这个接口。
IERC165 是 ERC165 标准的接口合约,规定了ERC165要实现的基本函数 supportsInterface

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


interface IERC165 {
   
    // ERC165 代币标准就是检查一个智能合约是不是支持了例如 ERC721 ,ERC1155 的接口。 
    // 如果支持,返回true
    function supportsInterface(
        bytes4 interfaceId
    ) external view returns (bool);
}

3、IERC721

IERC721 是 ERC721 标准的接口规范,它定义和规范了一个标准 ERC721 代币合约应该实现的功能。这里让 ERC721 合约直接继承自 IERC721() 接口。

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

import "./IERC165.sol";

// 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);
    
    // 返回某地址的NFT持有量balance
    function balanceOf(address owner) external view returns (uint256 balance);
    // 返回某 tokenId 的主人 owner
    function ownerOf(uint256 tokenId) external view returns (address owner);
    // 实现了 ERC721Receiver 接口的安全转账和重载函数  
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function safeTransferFrom(address from,address to,uint256 tokenId) external;
    // 普通转账,参数为转出地址from,接收地址to和tokenId。
    function transferFrom(address from,address to,uint256 tokenId) external;
            
    // 授权NFT给另外一个地址 to
    function approve(address to, uint256 tokenId) external;
    // 持有的该系列NFT批量授权给某个地址operator
    function setApprovalForAll(address operator, bool _approved) external;
    // 查询tokenId被批准给了哪个地址。
    function getApproved(uint256 tokenId) external view returns (address operator);
    // 查询某地址的NFT是否批量授权给了另一个operator地址
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

4、IERC721Receiver

为了防止 NFT 转入黑洞合约,ERC721 实现了 safeTransferFrom() 安全转账函数,目标合约必须实现了 IERC721Receiver 接口才能接收ERC721代币,不然会 revert 。

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


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

5、IERC721Metadata

IERC721Metadata 是 ERC721 的拓展接口,它定义了合约的元数据信息,包括合约名字、标志以及每个代币的 tokenURI。

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


interface IERC721Metadata {
   
    // 代币名称
    function name() external view returns (string memory);
    // 代币符号 
    function symbol() external view returns (string memory);
    // 通过 tokenId 查询 metadata 的链接url
    function tokenURI(uint256 tokenId) external view returns (string memory);
} 

6、ERC721

ERC-721 - 非同质化代币标准,主要用于发行独一无二的代币化资产如加密收藏品、游戏装备等。

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

import "./IERC165.sol";
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Strings.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地址。
    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 地址。
    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]);
    }

    // 转账函数
    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);   // 清空token的授权 
        _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
    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,同时释放Transfer事件。。
    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,同时释放Transfer事件。
    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);
    }

    // 调用IERC721Receiver-onERC721Received, 以防 tokenId 被不小心转入黑洞。
    function _checkOnERC721Received(address from, address to, uint tokenId, bytes memory _data) private returns (bool) {
   
        if (to.isContract()) {
   
            // 是否实现了 IERC721Receiver接口
            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拼接在一起,需要开发重写。
    function _baseURI() internal view virtual returns (string memory) {
   
        return "";
    }
}

7、ERC721 NFT 的实现

再写一个合约继承 ERC721 , 并写好 MAX_APES 状态变量、构造函数、baseURI 函数以及锻造 mint 函数。

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

import "./ERC721.sol";

contract NFTSang is ERC721 {
   
    uint public MAX_APES = 10000; // 总量

    // 构造函数
    constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_){
   
    }

    // ipfs://QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariAR3jxcaWtq/
    function _baseURI() internal pure override returns (string memory) {
   
        return "ipfs://QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariAR3jxcaWtq/";
    }
    
    // 铸造函数
    function mint(address to, uint tokenId) external {
   
        require(tokenId >= 0 && tokenId < MAX_APES, "tokenId out of range");
        _mint(to, tokenId);
    }
}

8、编译部署

redmix 可以直接编译运行。

在这里插入图片描述

免费锻造代币,正式使用需要开发者继续完善,比如规定哪些人有锻造此代币的权限。
在这里插入图片描述

相关推荐

  1. 区块链 | ERC721 标准

    2023-12-07 01:56:02       119 阅读
  2. solidity实战练习2--ERC20实现

    2023-12-07 01:56:02       29 阅读

最近更新

  1. docker php8.1+nginx base 镜像 dockerfile 配置

    2023-12-07 01:56:02       94 阅读
  2. Could not load dynamic library ‘cudart64_100.dll‘

    2023-12-07 01:56:02       101 阅读
  3. 在Django里面运行非项目文件

    2023-12-07 01:56:02       82 阅读
  4. Python语言-面向对象

    2023-12-07 01:56:02       91 阅读

热门阅读

  1. DELETE 请求,如何通过ajax进行发送

    2023-12-07 01:56:02       63 阅读
  2. K8S 容器和声明式资源

    2023-12-07 01:56:02       60 阅读
  3. 面试遇到的一些问题(二)

    2023-12-07 01:56:02       63 阅读
  4. 使用Plotly同时可视化表格和图表(Python)

    2023-12-07 01:56:02       55 阅读
  5. 1. 小游戏(贪心)

    2023-12-07 01:56:02       64 阅读
  6. C++ 共享内存ShellCode跨进程传输

    2023-12-07 01:56:02       46 阅读
  7. [node]Node.js多线程

    2023-12-07 01:56:02       59 阅读
  8. git的使用:基础配置和命令行

    2023-12-07 01:56:02       61 阅读
  9. 【数据仓库】-- 数据库设计的三个范式

    2023-12-07 01:56:02       64 阅读
  10. 【Linux】统计文件数量:ls -l | grep ^- | wc -l

    2023-12-07 01:56:02       49 阅读
  11. 壹财基金杨振骏:资本如何做好Web3布局?

    2023-12-07 01:56:02       54 阅读
  12. 控制系统设计中的scaled

    2023-12-07 01:56:02       57 阅读
  13. 泛型 (标签)

    2023-12-07 01:56:02       55 阅读