devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

以太坊应用层提案之ERC-721_erc721

作者：黑客灵魂 | 2024-07-10 18:58:48

赞

踩

erc721

一 NFT概述

1.1 什么是NFT

ERC-20是同质化代币标准，同质化的意思就是说，代币在单位内表示的价值和功能是一样， 代币之间是可以互换的。比如你现在有100个BNB， 那么每一个BNB价值和功能都是一样的。

但是，有时候我们希望给区块链中的虚拟资产赋予独特的、唯一的等特性的时候，比如对数字资产的所有权、纪念章、数字艺术品、各种唯一的虚拟物品，比如游戏道具等等，这时候同质化代币是做不到这一点，因此有了非同质化代币NFT，即Non-Fungible Tokens

NFT: 就是Non-Fungible Token，即非同质化代币，他也是以太坊区块链上一种虚拟数字资产，但是和同质化代币不同，它是唯一的，独特的，不可互换的代币，每一个NFT都具有独特的属性和价值。

1.2 Non-Fungible Token(NFT) 和 Fungible  Token(Token)比较

1.2.1 可互换性

Token是可以互换的，每一个Token的价值和功能是一样的

NFT: 不可互换，每一个NFT都是独一无二的，都可能具有不同价值

1.2.2 不可分割性

Token是可以分割的，通常可以分割为更小的单位进行交易。比如你可以购买0.1个或者0.001个代币

NFT通常不可分割，每个NFT都是一个完整的单位，你不能购买0.5个NFT

1.2.3 使用场景不一样

Token主要用于支付、交易和价值存储，适合需要标准化价值的场景

NFT主要用于表示独特的资产和所有权，适合需要强调独特性和所有权的场景。比如游戏道具、数字艺术品、数字收藏品、所有权、数字票据等等

二  ERC-721标准

2.1 什么是ERC-721

ERC-721是以太坊非同质化代币(NFT)的一个标准，它定义了一套规范或者标准，如果NFT实现了ERC-721标准，外部的钱包、交易所或者其他DApp应用程序就可以很方便的和NFT进行交互。

2.2 ERC-721特点

非同质化：

与同质化代币（如比特币和以太币）不同，ERC-721 代币是独特的，每个代币有其独特的属性和标识符。

这种独特性使得 ERC-721 代币特别适合表示独一无二的资产，如数字艺术品、收藏品、游戏物品等。

不可分割：

大多数 ERC-721 代币是不可分割的，即不能像同质化代币那样分割成更小的单位。一个完整的 ERC-721 代币必须作为一个整体进行交易。

所有权和转移：

ERC-721 标准定义了一组接口，使得NFT的所有权和转移过程可以在区块链上透明和安全地进行。代币的所有权信息被永久记录在区块链上，任何人都可以验证。

2.3 ERC-721标准内容

2.3.1 字段

和ERC-20不同，ERC-721因为要表示代币独一无二。因此，给NFT添加了一个tokenId的字段，表示该NFT独一无二。

另外，每一个NFT都有一个tokenURI，通常指向一个包含该代币详细信息的 JSON 文件，如名称、描述、图像链接等。这使得每个 NFT 可以有丰富的元数据，与其独特性相对应。比如:

{
    "title": "Louis Vena",
    "description": "Cneter Left",
    "image": "ipfs://QmX6pUBZDRt2uzw79iatA9zH9sbbDrrT1wThs8cjamqAkF",
    "attributes": [
        {
        "trait_type": "Singer",
        "value": "Belly"
        },
        {
        "trait_type": "Area",
        "value": "America"
        }
    ],
    "version": "1"
}

2.3.2 函数

2.3.2.1 balanceOf

function balanceOf(address _owner) external view returns (uint256);

返回指定地址的NFT余额，一个人可能会拥有多个

2.3.2.2 ownerOf

function ownerOf(uint256 _tokenId) external view returns (address);

根据指定的tokenId返回该NFT的拥有者地址

2.3.2.3 safeTransferFrom

function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;

安全的将指定的tokenId的NFT从_from地址转移到_to地址，并且还可以携带一些额外数据。

在复杂的交易场景中，可能需要附加的上下文信息。例如，某个 NFT 可能代表一个游戏中的物品，附加的数据可以包含关于游戏场景的信息。

在目标地址是合约时，附加的数据可以用来传递特定指令给合约。

function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

安全的将指定的tokenId的NFT从_from地址转移到_to地址，不能携带一些额外数据

2.3.2.4 transferFrom

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

将指定的tokenId的NFT从_from地址转移到_to地址

2.3.2.5 approve

function approve(address _approved, uint256 _tokenId) external payable;

授权某个地址_approved可以转移指定tokenId的NFT。

2.3.2.6 setApprovalForAll

function setApprovalForAll(address _operator, bool _approved) external;

授权或取消授权_operator地址可以管理调用者的所有NFT

2.3.2.7 getApproved

function getApproved(uint256 _tokenId) external view returns (address);

返回指定tokenId的NFT被授权哪个地址可以进行转移

2.3.2.8 isApprovedForAll

function isApprovedForAll(address _owner, address _operator) external view returns (bool);

是否_operator是否被授权管理_owner的所有NFT

2.3.3 事件

2.3.3.1 Transfer

event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);

在代币转移时需要触发

2.3.3.2 Approval

event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);

在代币授权时触发

2.3.3.3 ApprovalForAll

event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

在设置或取消所有授权时触发

三 safeTransferFrom和transferFrom比较

function safeTransferFrom(address from, address to, uint256 tokenId) external;

function transferFrom(address from, address to, uint256 tokenId) external;

3.1 相同点

都是将 指定tokenId的NFT 从 `from` 地址转移到` to` 地址

3.2 不同点

不同点主要是安全问题：

我们知道智能合约地址一般分为EOA地址和CA地址，那么钱包一般属于EOA地址，这类地址他们不会有代码的执行，仅用于持有和发送代币等；但是CA地址就是合约地址，合约地址是可以有代码执行逻辑的。

那这个和NFT转移安全有什么关系呢?  难道CA地址就无法转移成功，EOA地址就可以?

其实是这样的，无论是EOA地址还是CA地址，safeTransferFrom和transferFrom都是可以转移成功的。但是转移给CA地址，需要考虑到这个合约是否有接口可以把NFT转出来，如果转不出来，那么这个NFT就一直在这个合约里面了。因此，如果 to 地址是一个不支持 操作ERC721的合约，最后safeTransferFrom就会revert, 这笔交易不会成功。

那safeTransferFrom是怎么实现检查合约是否具备操作NFT的能力的呢?

在OpenZeppelin中，定义了一个ERC721Receiver接口，如果你的合约你觉得需要让调用者知晓你是具备操作ERC721的能力的，比如转账，那么你需要在你的合约中实现这个ERC721Receiver接口的onERC721Received函数；否则调用者就无法知晓你这个合约到底是不是支持ERC721接口的，那么safeTransferFrom就会认为不支持，则判定失败，回滚交易。

  1. function onERC721Received(
  3.         address operator,
  5.         address from,
  7.         uint256 tokenId,
  9.         bytes calldata data
  11. ) external returns (bytes4);

那么实现了或者重载了，怎么认为他就具备处理ERC721的能力了？只需要这个函数返回值是`bytes4`类型，并且返回值为`this.onERC721Received.selector`，这样可以确保函数符合ERC721接口中定义的规范。比如:

  1. function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external override returns (bytes4) {
  2.  
  3.         // 这里可以添加处理逻辑，例如记录接收到的代币信息
  4.  
  5.         // 返回这个值表明成功接收
  6.  
  7.         return this.onERC721Received.selector;
  8.  
  9. }

四 手动实现ERC-721

  1. // SPDX-License-Identifier: UNLICENSED
  2.  
  3. pragma solidity ^0.8.13;
  4.  
  5. import "./IERC721.sol";
  6.  
  7.  
  8.  
  9. abstract contract ERC720 is IERC721 {
  10.  
  11.     string private _name;
  12.  
  13.     string private _symbol;
  14.  
  15.  
  16.  
  17.     mapping(uint256 => address) private _owners;
  18.  
  19.     mapping(address => uint256) private _balances;
  20.  
  21.     mapping(uint256 => address) private _approvals;
  22.  
  23.     mapping(address owner => mapping(address operator => bool))
  24.  
  25.         private _operatorApprovals;
  26.  
  27.  
  28.  
  29.     constructor(string memory name, string memory symbol) {
  30.  
  31.         _name = name;
  32.  
  33.         _symbol = symbol;
  34.  
  35.     }
  36.  
  37.  
  38.  
  39.     function name() public view virtual returns (string memory) {
  40.  
  41.         return _name;
  42.  
  43.     }
  44.  
  45.  
  46.  
  47.     function symbol() public view virtual returns (string memory) {
  48.  
  49.         return _symbol;
  50.  
  51.     }
  52.  
  53.  
  54.  
  55.     function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
  56.  
  57.         require(_owners[tokenId] != address(0), "Not exists owner");
  58.  
  59.  
  60.  
  61.         string memory baseURI = _baseURI();
  62.  
  63.         return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
  64.  
  65.     }
  66.  
  67.  
  68.  
  69.     // Any contract extends the ERC721 contract could ovveride the function and set the baseURI value, default is empty string
  70.  
  71.     function _baseURI() internal view virtual returns (string memory) {
  72.  
  73.         return "";
  74.  
  75.     }
  76.  
  77.  
  78.  
  79.     function balanceOf(
  81.         address owner
  83.     ) external view override returns (uint256 balance) {
  84.  
  85.         return _balances[owner];
  86.  
  87.     }
  88.  
  89.  
  90.  
  91.     function ownerOf(
  93.         uint256 tokenId
  95.     ) external view override returns (address owner) {
  96.  
  97.         return _owners[tokenId];
  98.  
  99.     }
  100.  
  101.  
  102.  
  103.     function safeTransferFrom(
  105.         address from,
  107.         address to,
  109.         uint256 tokenId,
  111.         bytes calldata data
  113.     ) external override {
  114.  
  115.         _checkOnERC721Received(from, to, tokenId, data);
  116.  
  117.         transferFrom(from, to, tokenId);
  118.  
  119.     }
  120.  
  121.  
  122.  
  123.     function safeTransferFrom(
  125.         address from,
  127.         address to,
  129.         uint256 tokenId
  131.     ) external override {
  132.  
  133.         safeTransferFrom(from, to, tokenId, "");
  134.  
  135.     }
  136.  
  137.  
  138.  
  139.     /**
  141.      * Transfer ownership of an NFT
  143.      * @param from
  145.      * @param to
  147.      * @param tokenId
  149.      */
  150.  
  151.     function transferFrom(
  153.         address from,
  155.         address to,
  157.         uint256 tokenId
  159.     ) external override {
  160.  
  161.         // check if msg.sender has approved
  162.  
  163.         require(_checkPermission(from, msg.sender, tokenId), "msg.sender has no previleges to transfer");
  164.  
  165.         // update owner balance
  166.  
  167.         address prev = _update(to, tokenId, msg.sender);
  168.  
  169.         require(prev == from, "Incorrect owner");
  170.  
  171.     }
  172.  
  173.  
  174.  
  175.     // Approve permisson to `to` address for tokenId
  176.  
  177.     function approve(address to, uint256 tokenId) external override {
  178.  
  179.         _approve(to, tokenId, msg.sender);
  180.  
  181.     }
  182.  
  183.  
  184.  
  185.     function setApprovalForAll(
  187.         address operator,
  189.         bool approved
  191.     ) external override {
  192.  
  193.         require(operator != address(0), "Invalid operator");
  194.  
  195.         _operatorApprovals[msg.sender][operator] = approved;
  196.  
  197.         emit ApprovalForAll(msg.sender, operator, approved);
  198.  
  199.     }
  200.  
  201.  
  202.  
  203.     function getApproved(
  205.         uint256 tokenId
  207.     ) external view override returns (address operator) {
  208.  
  209.         require(_owners[tokenId] != address(0), "Not exist owner");
  210.  
  211.         return _getApproved(tokenId);
  212.  
  213.     }
  214.  
  215.  
  216.  
  217.     function isApprovedForAll(
  219.         address owner,
  221.         address operator
  223.     ) public view override returns (bool) {
  224.  
  225.         return _operatorApprovals[owner][operator];
  226.  
  227.     }
  228.  
  229.  
  230.  
  231.     function _update(address to, uint256 tokenId, address operator) internal virtual returns (address) {
  232.  
  233.         address from = _owners[tokenId];
  234.  
  235.  
  236.  
  237.         if (operator != address(0)) {
  238.  
  239.             _checkPermission(from, operator, tokenId);
  240.  
  241.         }
  242.  
  243.  
  244.  
  245.         if (from != address(0)) {
  246.  
  247.             unchecked {
  248.  
  249.                 _balances[from] -= 1;
  250.  
  251.             }
  252.  
  253.         }
  254.  
  255.  
  256.  
  257.         if (to != address(0)) {
  258.  
  259.             unchecked {
  260.  
  261.                 _balances[to] += 1;
  262.  
  263.             }
  264.  
  265.         }
  266.  
  267.  
  268.  
  269.         _owners[tokenId] = to;
  270.  
  271.  
  272.  
  273.         emit Transfer(from, to, tokenId);
  274.  
  275.  
  276.  
  277.         return from;
  278.  
  279.     }
  280.  
  281.  
  282.  
  283.     function _approve(address to, uint256 tokenId, address owner) internal virtual {
  284.  
  285.         require(_owners[tokenId] == owner, "Incorrect owner address")
  286.  
  287.         require(to != address(0), "Invalid to address");
  288.  
  289.         _approvals[tokenId] = to;
  290.  
  291.         emit Approval(owner, to, tokenId);
  292.  
  293.     }
  294.  
  295.  
  296.  
  297.     function _getApproved(uint256 tokenId) internal view virtual returns (address) {
  298.  
  299.         return approvals[tokenId];
  300.  
  301.     }
  302.  
  303.  
  304.  
  305.     /*
  307.      * Check if owner approved for spender about the tokenId
  309.      * @param owner
  311.      * @param spender
  313.      * @param tokenId
  315.      */
  316.  
  317.     function _checkPermission(address owner, address operator, uint256 tokenId) internal returns (bool) {
  318.  
  319.         require(_owners[tokenId] == owner, "Incorrect owner");
  320.  
  321.         require(operator != address(0), "Illegal operator address");
  322.  
  323.         // If operator is owner, so operator must have the permission
  324.  
  325.         if (owner == operator) {
  326.  
  327.             return true;
  328.  
  329.         }
  330.  
  331.  
  332.  
  333.         // If operator is approved, return true
  334.  
  335.         if (_getApproved(tokenId) == operator) {
  336.  
  337.             return true;
  338.  
  339.         }
  340.  
  341.  
  342.  
  343.         return isApprovedForAll(owner, operator);
  344.  
  345.     }
  346.  
  347.  
  348.  
  349.     function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) internal {
  350.  
  351.         // check smart contract code length, EOA address length is zero, CA address length is greater than zero
  352.  
  353.         if (to.code.length > 0) {
  354.  
  355.             // if to address is contract address, see if implements the IERC721Receiver interface
  356.  
  357.             // if IERC721Receiver.onERC721Received return value is IERC721Receiver.onERC721Received.selector
  358.  
  359.             // it means the contract could operate NFT, such as transfer .etc
  360.  
  361.             try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
  362.  
  363.                 if (retval != IERC721Receiver.onERC721Received.selector) {
  364.  
  365.                     revert ERC721InvalidReceiver(to);
  366.  
  367.                 }
  368.  
  369.             } catch (bytes memory reason) {
  370.  
  371.                 if (reason.length == 0) {
  372.  
  373.                     revert ERC721InvalidReceiver(to);
  374.  
  375.                 } else {
  376.  
  377.                     assembly {
  378.  
  379.                         revert(add(32, reason), mload(reason))
  380.  
  381.                     }
  382.  
  383.                 }
  384.  
  385.             }
  386.  
  387.         }
  388.  
  389.     }
  390.  
  391.  
  392.  
  393.     /**
  395.      * Get nft approver address by tokenId
  397.      */
  398.  
  399.     function _getApproved(uint256 tokenId) internal view virtual returns (address) {
  400.  
  401.         return _approvals[tokenId];
  402.  
  403.     }
  404.  
  405.  
  406.  
  407.     /**
  409.      * Mint nft to `to` address
  411.      * @param to
  413.      * @param tokenId
  415.      */
  416.  
  417.     function _mint(address to, uint256 tokenId) internal {
  418.  
  419.         require(to != address(0), "Invalid mint address");
  420.  
  421.         unchecked {
  422.  
  423.             _balances[to] += 1;
  424.  
  425.         }
  426.  
  427.         _owners[tokenId] = to;
  428.  
  429.  
  430.  
  431.         emit Transfer(from, to, tokenId);
  432.  
  433.     }
  434.  
  435.  
  436.  
  437.     function _safeMint(address to, uint256 tokenId) internal {
  438.  
  439.         _safeMint(to, tokenId, "");
  440.  
  441.     }
  442.  
  443.  
  444.  
  445.     function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
  446.  
  447.         _mint(to, tokenId);
  448.  
  449.         _checkOnERC721Received(address(0), to, tokenId, data);
  450.  
  451.     }   
  452.  
  453. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/807295
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号