Vyper ERC-721 合约详解

1# @dev ERC-721 非同质化代币标准的实现。
2# @author Ryuya Nakamura (@nrryuya)
3# 修改自：https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
复制

1from vyper.interfaces import ERC721
2
3implements: ERC721
复制

1# safeTransferFrom() 调用的合约接口
2interface ERC721Receiver:
3    def onERC721Received(
复制

1            _operator: address,
2            _from: address,
复制

1            _tokenId: uint256,
复制

1            _data: Bytes[1024]
复制

1        ) -> bytes32: view
复制

1# @dev 当任何 NFT 的所有权因任何机制发生变化时发出。当 NFT 被
2#      创建（`from` == 0）和销毁（`to` == 0）时，会发出此事件。例外：在合约创建期间，可以
3#      创建和分配任意数量的 NFT 而不发出 Transfer 事件。在任何
4#      转账时，该 NFT 的批准地址（如有）将被重置为无。
5# @param _from NFT 的发送者（如果地址是零地址，则表示代币创建）。
6# @param _to NFT 的接收者（如果地址是零地址，则表示代币销毁）。
7# @param _tokenId 被转移的 NFT。
8event Transfer:
9    sender: indexed(address)
10    receiver: indexed(address)
11    tokenId: indexed(uint256)
显示全部
复制

1# @dev 当 NFT 的批准地址被更改或重新确认时发出此事件。零
2#      地址表示没有批准地址。当 Transfer 事件发出时，这也
3#      表示该 NFT 的批准地址（如有）被重置为无。
4# @param _owner NFT 的所有者。
5# @param _approved 我们正在批准的地址。
6# @param _tokenId 我们正在批准的 NFT。
7event Approval:
8    owner: indexed(address)
9    approved: indexed(address)
10    tokenId: indexed(uint256)
显示全部
复制

1# @dev 当为所有者启用或禁用操作员时发出此事件。操作员可以管理
2#      所有者的所有 NFT。
3# @param _owner NFT 的所有者。
4# @param _operator 我们正在为其设置操作员权限的地址。
5# @param _approved 操作员权限的状态（如果授予操作员权限则为 true，如果
6# 撤销则为 false）。
7event ApprovalForAll:
8    owner: indexed(address)
9    operator: indexed(address)
10    approved: bool
显示全部
复制

1# @dev 从 NFT ID 到其所有者地址的映射。
2idToOwner: HashMap[uint256, address]
3
4# @dev 从 NFT ID 到批准地址的映射。
5idToApprovals: HashMap[uint256, address]
复制

1# @dev 从所有者地址到其代币数量的映射。
2ownerToNFTokenCount: HashMap[address, uint256]
复制

1# @dev 从所有者地址到操作员地址映射的映射。
2ownerToOperators: HashMap[address, HashMap[address, bool]]
复制

1# @dev 铸币者地址，可以铸造代币
2minter: address
复制

1# @dev 接口 ID 到布尔值的映射，表示是否支持该接口
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165 的 ERC165 接口 ID
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC721 的 ERC165 接口 ID
8ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
复制

1@external
2def __init__():
复制

1    """
2    @dev 合约构造函数。
3    """
复制

1    self.supportedInterfaces[ERC165_INTERFACE_ID] = True
2    self.supportedInterfaces[ERC721_INTERFACE_ID] = True
3    self.minter = msg.sender
复制

1@view
2@external
复制

1def supportsInterface(_interfaceID: bytes32) -> bool:
复制

1    """
2    @dev 接口标识在 ERC-165 中指定。
3    @param _interfaceID 接口的 ID
4    """
5    return self.supportedInterfaces[_interfaceID]
复制

1### 视图函数 ###
复制

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev 返回 `_owner` 拥有的 NFT 数量。
6         如果 `_owner` 是零地址，则抛出异常。分配给零地址的 NFT 被视为无效。
7    @param _owner 查询余额的地址。
8    """
9    assert _owner != ZERO_ADDRESS
显示全部
复制

1    return self.ownerToNFTokenCount[_owner]
2
3@view
4@external
5def ownerOf(_tokenId: uint256) -> address:
6    """
7    @dev 返回 NFT 所有者的地址。
8         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
9    @param _tokenId NFT 的标识符。
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
13    assert owner != ZERO_ADDRESS
14    return owner
显示全部
复制

1@view
2@external
3def getApproved(_tokenId: uint256) -> address:
4    """
5    @dev 获取单个 NFT 的批准地址。
6         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
7    @param _tokenId 要查询其批准情况的 NFT 的 ID。
8    """
9    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
10    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
11    return self.idToApprovals[_tokenId]
显示全部
复制

1@view
2@external
3def isApprovedForAll(_owner: address, _operator: address) -> bool:
4    """
5    @dev 检查 `_operator` 是否是 `_owner` 的批准操作员。
6    @param _owner 拥有 NFT 的地址。
7    @param _operator 代表所有者行事的地址。
8    """
9    return (self.ownerToOperators[_owner])[_operator]
显示全部
复制

1
2### 转账函数辅助 ###
3
4@view
5@internal
复制

1def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
2    """
3    @dev 返回给定的支出者是否可以转移给定的代币 ID
4    @param spender 要查询的支出者地址
5    @param tokenId 要转移的代币的 uint256 ID
6    @return bool，表示 msg.sender 是否被批准用于给定的代币 ID，
7        是所有者的操作员，还是代币的所有者
8    """
9    owner: address = self.idToOwner[_tokenId]
10    spenderIsOwner: bool = owner == _spender
11    spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
12    spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
13    return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
显示全部
复制

1@internal
2def _addTokenTo(_to: address, _tokenId: uint256):
3    """
4    @dev 将一个 NFT 添加到给定地址
5         如果 `_tokenId` 已被某人拥有，则抛出异常。
6    """
7    # 如果 `_tokenId` 已被某人拥有，则抛出异常
8    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
9    # 更改所有者
10    self.idToOwner[_tokenId] = _to
11    # 更改计数跟踪
12    self.ownerToNFTokenCount[_to] += 1
13
14
15@internal
16def _removeTokenFrom(_from: address, _tokenId: uint256):
17    """
18    @dev 从给定地址移除一个 NFT
19         如果 `_from` 不是当前所有者，则抛出异常。
20    """
21    # 如果 `_from` 不是当前所有者，则抛出异常
22    assert self.idToOwner[_tokenId] == _from
23    # 更改所有者
24    self.idToOwner[_tokenId] = ZERO_ADDRESS
25    # 更改计数跟踪
26    self.ownerToNFTokenCount[_from] -= 1
显示全部
复制

1@internal
2def _clearApproval(_owner: address, _tokenId: uint256):
3    """
4    @dev 清除给定地址的批准
5         如果 `_owner` 不是当前所有者，则抛出异常。
6    """
7    # 如果 `_owner` 不是当前所有者，则抛出异常
8    assert self.idToOwner[_tokenId] == _owner
9    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
10        # 重置批准
11        self.idToApprovals[_tokenId] = ZERO_ADDRESS
显示全部
复制

1@internal
2def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
3    """
4    @dev 执行 NFT 的转移。
5         除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
6         地址，否则抛出异常。（注意：私有函数中不允许使用 `msg.sender`，因此传递 `_sender`。）
7         如果 `_to` 是零地址，则抛出异常。
8         如果 `_from` 不是当前所有者，则抛出异常。
9         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
10    """
显示全部
复制

1    # 检查要求
2    assert self._isApprovedOrOwner(_sender, _tokenId)
3    # 如果 `_to` 是零地址，则抛出异常
4    assert _to != ZERO_ADDRESS
5    # 清除批准。如果 `_from` 不是当前所有者，则抛出异常
6    self._clearApproval(_from, _tokenId)
7    # 移除 NFT。如果 `_tokenId` 不是有效的 NFT，则抛出异常
8    self._removeTokenFrom(_from, _tokenId)
9    # 添加 NFT
10    self._addTokenTo(_to, _tokenId)
11    # 记录转账
12    log Transfer(_from, _to, _tokenId)
显示全部
复制

1
2### 转账函数 ###
3
4@external
5def transferFrom(_from: address, _to: address, _tokenId: uint256):
6    """
7    @dev 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
8         地址，否则抛出异常。
9         如果 `_from` 不是当前所有者，则抛出异常。
10         如果 `_to` 是零地址，则抛出异常。
11         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
12    @notice 调用者有责任确认 `_to` 能够接收 NFT，否则
13            它们可能会永久丢失。
14    @param _from NFT 的当前所有者。
15    @param _to 新的所有者。
16    @param _tokenId 要转移的 NFT。
17    """
18    self._transferFrom(_from, _to, _tokenId, msg.sender)
显示全部
复制

1@external
2def safeTransferFrom(
3        _from: address,
4        _to: address,
5        _tokenId: uint256,
6        _data: Bytes[1024]=b""
7    ):
8    """
9    @dev 将一个 NFT 的所有权从一个地址转移到另一个地址。
10         除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的
11         批准地址，否则抛出异常。
12         如果 `_from` 不是当前所有者，则抛出异常。
13         如果 `_to` 是零地址，则抛出异常。
14         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
15         如果 `_to` 是一个智能合约，它会在 `_to` 上调用 `onERC721Received`，如果
16         返回值不是 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`，则抛出异常。
17         注意：bytes4 由带填充的 bytes32 表示
18    @param _from NFT 的当前所有者。
19    @param _to 新的所有者。
20    @param _tokenId 要转移的 NFT。
21    @param _data 没有指定格式的附加数据，在调用 `_to` 时发送。
22    """
23    self._transferFrom(_from, _to, _tokenId, msg.sender)
显示全部
复制

1    if _to.is_contract: # 检查 `_to` 是否是合约地址
复制

1        returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
复制

1        # 如果转移目标是一个未实现 'onERC721Received' 的合约，则抛出异常
2        assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
复制

1@external
2def approve(_approved: address, _tokenId: uint256):
3    """
4    @dev 为一个 NFT 设置或重新确认批准地址。零地址表示没有批准地址。
5         除非 `msg.sender` 是当前的 NFT 所有者，或者是当前所有者的授权操作员，否则抛出异常。
6         如果 `_tokenId` 不是有效的 NFT，则抛出异常。（注意：这并未写入 EIP）
7         如果 `_approved` 是当前所有者，则抛出异常。（注意：这并未写入 EIP）
8    @param _approved 要为给定 NFT ID 批准的地址。
9    @param _tokenId 要批准的代币 ID。
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
13    assert owner != ZERO_ADDRESS
14    # 如果 `_approved` 是当前所有者，则抛出异常
15    assert _approved != owner
显示全部
复制

1    # 检查要求
2    senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
3    senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
4    assert (senderIsOwner or senderIsApprovedForAll)
复制

1    # 设置批准
2    self.idToApprovals[_tokenId] = _approved
3    log Approval(owner, _approved, _tokenId)
4
5
6@external
7def setApprovalForAll(_operator: address, _approved: bool):
8    """
9    @dev 为第三方（“操作员”）启用或禁用批准，以管理
10         `msg.sender` 的所有资产。它还会发出 ApprovalForAll 事件。
11         如果 `_operator` 是 `msg.sender`，则抛出异常。（注意：这并未写入 EIP）
12    @notice 即使发送者当时不拥有任何代币，此操作也有效。
13    @param _operator 要添加到授权操作员集合中的地址。
14    @param _approved 如果操作员被批准，则为 True；如果撤销批准，则为 false。
15    """
16    # 如果 `_operator` 是 `msg.sender`，则抛出异常
17    assert _operator != msg.sender
18    self.ownerToOperators[msg.sender][_operator] = _approved
19    log ApprovalForAll(msg.sender, _operator, _approved)
显示全部
复制

1### 铸造和销毁函数 ###
2
3@external
4def mint(_to: address, _tokenId: uint256) -> bool:
复制

1    """
2    @dev 铸造代币的函数
3         如果 `msg.sender` 不是铸币者，则抛出异常。
4         如果 `_to` 是零地址，则抛出异常。
5         如果 `_tokenId` 已被某人拥有，则抛出异常。
6    @param _to 将接收铸造代币的地址。
7    @param _tokenId 要铸造的代币 id。
8    @return 一个布尔值，指示操作是否成功。
9    """
10    # 如果 `msg.sender` 不是铸币者，则抛出异常
11    assert msg.sender == self.minter
显示全部
复制

1    # 如果 `_to` 是零地址，则抛出异常
2    assert _to != ZERO_ADDRESS
3    # 添加 NFT。如果 `_tokenId` 已被某人拥有，则抛出异常
4    self._addTokenTo(_to, _tokenId)
5    log Transfer(ZERO_ADDRESS, _to, _tokenId)
6    return True
复制

1
2@external
3def burn(_tokenId: uint256):
4    """
5    @dev 销毁一个特定的 ERC721 代币。
6         除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
7         地址，否则抛出异常。
8         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
9    @param _tokenId 要销毁的 ERC721 代币的 uint256 id。
10    """
11    # 检查要求
12    assert self._isApprovedOrOwner(msg.sender, _tokenId)
13    owner: address = self.idToOwner[_tokenId]
14    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
15    assert owner != ZERO_ADDRESS
16    self._clearApproval(owner, _tokenId)
17    self._removeTokenFrom(owner, _tokenId)
18    log Transfer(owner, ZERO_ADDRESS, _tokenId)
显示全部
复制