Vyper ERC-721 合约详解

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

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

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

@view
@external
def balanceOf(_owner: address) -> uint256:
    """
    @dev 返回 `_owner` 拥有的 NFT 数量。
         如果 `_owner` 是零地址，则抛出异常。分配给零地址的 NFT 被视为无效。
    @param _owner 查询余额的地址。
    """
    assert _owner != ZERO_ADDRESS

    return self.ownerToNFTokenCount[_owner]

@view
@external
def ownerOf(_tokenId: uint256) -> address:
    """
    @dev 返回 NFT 所有者的地址。
         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
    @param _tokenId NFT 的标识符。
    """
    owner: address = self.idToOwner[_tokenId]
    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
    assert owner != ZERO_ADDRESS
    return owner

@view
@external
def getApproved(_tokenId: uint256) -> address:
    """
    @dev 获取单个 NFT 的批准地址。
         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
    @param _tokenId 要查询其批准情况的 NFT 的 ID。
    """
    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
    return self.idToApprovals[_tokenId]

@view
@external
def isApprovedForAll(_owner: address, _operator: address) -> bool:
    """
    @dev 检查 `_operator` 是否是 `_owner` 的批准操作员。
    @param _owner 拥有 NFT 的地址。
    @param _operator 代表所有者行事的地址。
    """
    return (self.ownerToOperators[_owner])[_operator]

def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
    """
    @dev 返回给定的支出者是否可以转移给定的代币 ID
    @param spender 要查询的支出者地址
    @param tokenId 要转移的代币的 uint256 ID
    @return bool，表示 msg.sender 是否被批准用于给定的代币 ID，
        是所有者的操作员，还是代币的所有者
    """
    owner: address = self.idToOwner[_tokenId]
    spenderIsOwner: bool = owner == _spender
    spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
    spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
    return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll

@internal
def _addTokenTo(_to: address, _tokenId: uint256):
    """
    @dev 将一个 NFT 添加到给定地址
         如果 `_tokenId` 已被某人拥有，则抛出异常。
    """
    # 如果 `_tokenId` 已被某人拥有，则抛出异常
    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
    # 更改所有者
    self.idToOwner[_tokenId] = _to
    # 更改计数跟踪
    self.ownerToNFTokenCount[_to] += 1


@internal
def _removeTokenFrom(_from: address, _tokenId: uint256):
    """
    @dev 从给定地址移除一个 NFT
         如果 `_from` 不是当前所有者，则抛出异常。
    """
    # 如果 `_from` 不是当前所有者，则抛出异常
    assert self.idToOwner[_tokenId] == _from
    # 更改所有者
    self.idToOwner[_tokenId] = ZERO_ADDRESS
    # 更改计数跟踪
    self.ownerToNFTokenCount[_from] -= 1

@internal
def _clearApproval(_owner: address, _tokenId: uint256):
    """
    @dev 清除给定地址的批准
         如果 `_owner` 不是当前所有者，则抛出异常。
    """
    # 如果 `_owner` 不是当前所有者，则抛出异常
    assert self.idToOwner[_tokenId] == _owner
    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
        # 重置批准
        self.idToApprovals[_tokenId] = ZERO_ADDRESS

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

    # 检查要求
    assert self._isApprovedOrOwner(_sender, _tokenId)
    # 如果 `_to` 是零地址，则抛出异常
    assert _to != ZERO_ADDRESS
    # 清除批准。如果 `_from` 不是当前所有者，则抛出异常
    self._clearApproval(_from, _tokenId)
    # 移除 NFT。如果 `_tokenId` 不是有效的 NFT，则抛出异常
    self._removeTokenFrom(_from, _tokenId)
    # 添加 NFT
    self._addTokenTo(_to, _tokenId)
    # 记录转账
    log Transfer(_from, _to, _tokenId)

### 转账函数 ###

@external
def transferFrom(_from: address, _to: address, _tokenId: uint256):
    """
    @dev 除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
         地址，否则抛出异常。
         如果 `_from` 不是当前所有者，则抛出异常。
         如果 `_to` 是零地址，则抛出异常。
         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
    @notice 调用者有责任确认 `_to` 能够接收 NFT，否则
            它们可能会永久丢失。
    @param _from NFT 的当前所有者。
    @param _to 新的所有者。
    @param _tokenId 要转移的 NFT。
    """
    self._transferFrom(_from, _to, _tokenId, msg.sender)

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

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

    # 设置批准
    self.idToApprovals[_tokenId] = _approved
    log Approval(owner, _approved, _tokenId)


@external
def setApprovalForAll(_operator: address, _approved: bool):
    """
    @dev 为第三方（“操作员”）启用或禁用批准，以管理
         `msg.sender` 的所有资产。它还会发出 ApprovalForAll 事件。
         如果 `_operator` 是 `msg.sender`，则抛出异常。（注意：这并未写入 EIP）
    @notice 即使发送者当时不拥有任何代币，此操作也有效。
    @param _operator 要添加到授权操作员集合中的地址。
    @param _approved 如果操作员被批准，则为 True；如果撤销批准，则为 false。
    """
    # 如果 `_operator` 是 `msg.sender`，则抛出异常
    assert _operator != msg.sender
    self.ownerToOperators[msg.sender][_operator] = _approved
    log ApprovalForAll(msg.sender, _operator, _approved)

    """
    @dev 铸造代币的函数
         如果 `msg.sender` 不是铸币者，则抛出异常。
         如果 `_to` 是零地址，则抛出异常。
         如果 `_tokenId` 已被某人拥有，则抛出异常。
    @param _to 将接收铸造代币的地址。
    @param _tokenId 要铸造的代币 id。
    @return 一个布尔值，指示操作是否成功。
    """
    # 如果 `msg.sender` 不是铸币者，则抛出异常
    assert msg.sender == self.minter

@external
def burn(_tokenId: uint256):
    """
    @dev 销毁一个特定的 ERC721 代币。
         除非 `msg.sender` 是当前所有者、授权操作员或此 NFT 的批准
         地址，否则抛出异常。
         如果 `_tokenId` 不是有效的 NFT，则抛出异常。
    @param _tokenId 要销毁的 ERC721 代币的 uint256 id。
    """
    # 检查要求
    assert self._isApprovedOrOwner(msg.sender, _tokenId)
    owner: address = self.idToOwner[_tokenId]
    # 如果 `_tokenId` 不是有效的 NFT，则抛出异常
    assert owner != ZERO_ADDRESS
    self._clearApproval(owner, _tokenId)
    self._removeTokenFrom(owner, _tokenId)
    log Transfer(owner, ZERO_ADDRESS, _tokenId)