Vyper ERC-721 合约概览

1# @dev Implementation of ERC-721 non-fungible token standard.
2# @author Ryuya Nakamura (@nrryuya)
3# Modified from: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
复制

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

1# Interface for the contract called by safeTransferFrom()
2interface ERC721Receiver:
3    def onERC721Received(
复制

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

1            _tokenId: uint256,
复制

1            _data: Bytes[1024]
复制

1        ) -> bytes32: view
复制

1# @dev Emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are
2#      created (`from` == 0) and destroyed (`to` == 0). Exception: during contract creation, any
3#      number of NFTs may be created and assigned without emitting Transfer. At the time of any
4#      transfer, the approved address for that NFT (if any) is reset to none.
5# @param _from Sender of NFT (if address is zero address it indicates token creation).
6# @param _to Receiver of NFT (if address is zero address it indicates token destruction).
7# @param _tokenId The NFT that got transferred.
8event Transfer:
9    sender: indexed(address)
10    receiver: indexed(address)
11    tokenId: indexed(uint256)
显示全部
复制

1# @dev This emits when the approved address for an NFT is changed or reaffirmed. The zero
2#      address indicates there is no approved address. When a Transfer event emits, this also
3#      indicates that the approved address for that NFT (if any) is reset to none.
4# @param _owner Owner of NFT.
5# @param _approved Address that we are approving.
6# @param _tokenId NFT which we are approving.
7event Approval:
8    owner: indexed(address)
9    approved: indexed(address)
10    tokenId: indexed(uint256)
显示全部
复制

1# @dev This emits when an operator is enabled or disabled for an owner. The operator can manage
2#      all NFTs of the owner.
3# @param _owner Owner of NFT.
4# @param _operator Address to which we are setting operator rights.
5# @param _approved Status of operator rights(true if operator rights are given and false if
6# revoked).
7event ApprovalForAll:
8    owner: indexed(address)
9    operator: indexed(address)
10    approved: bool
显示全部
复制

1# @dev Mapping from NFT ID to the address that owns it.
2idToOwner: HashMap[uint256, address]
3
4# @dev Mapping from NFT ID to approved address.
5idToApprovals: HashMap[uint256, address]
复制

1# @dev Mapping from owner address to count of his tokens.
2ownerToNFTokenCount: HashMap[address, uint256]
复制

1# @dev Mapping from owner address to mapping of operator addresses.
2ownerToOperators: HashMap[address, HashMap[address, bool]]
复制

1# @dev Address of minter, who can mint a token
2minter: address
复制

1# @dev Mapping of interface id to bool about whether or not it's supported
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165 interface ID of ERC165
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC165 interface ID of ERC721
8ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
复制

1@external
2def __init__():
复制

1    """
2    @dev Contract constructor.
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 Interface identification is specified in ERC-165.
3    @param _interfaceID Id of the interface
4    """
5    return self.supportedInterfaces[_interfaceID]
复制

1### VIEW FUNCTIONS ###
复制

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev Returns the number of NFTs owned by `_owner`.
6         Throws if `_owner` is the zero address. NFTs assigned to the zero address are considered invalid.
7    @param _owner Address for whom to query the balance.
8    """
9    assert _owner != ZERO_ADDRESS
显示全部
复制

1    return self.ownerToNFTokenCount[_owner]
2
3@view
4@external
5def ownerOf(_tokenId: uint256) -> address:
6    """
7    @dev Returns the address of the owner of the NFT.
8         Throws if `_tokenId` is not a valid NFT.
9    @param _tokenId The identifier for an NFT.
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # Throws if `_tokenId` is not a valid NFT
13    assert owner != ZERO_ADDRESS
14    return owner
显示全部
复制

1@view
2@external
3def getApproved(_tokenId: uint256) -> address:
4    """
5    @dev Get the approved address for a single NFT.
6         Throws if `_tokenId` is not a valid NFT.
7    @param _tokenId ID of the NFT to query the approval of.
8    """
9    # Throws if `_tokenId` is not a valid 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 Checks if `_operator` is an approved operator for `_owner`.
6    @param _owner The address that owns the NFTs.
7    @param _operator The address that acts on behalf of the owner.
8    """
9    return (self.ownerToOperators[_owner])[_operator]
显示全部
复制

1
2### TRANSFER FUNCTION HELPERS ###
3
4@view
5@internal
复制

1def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
2    """
3    @dev Returns whether the given spender can transfer a given token ID
4    @param spender address of the spender to query
5    @param tokenId uint256 ID of the token to be transferred
6    @return bool whether the msg.sender is approved for the given token ID,
7        is an operator of the owner, or is the owner of the token
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 Add a NFT to a given address
5         Throws if `_tokenId` is owned by someone.
6    """
7    # Throws if `_tokenId` is owned by someone
8    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
9    # Change the owner
10    self.idToOwner[_tokenId] = _to
11    # Change count tracking
12    self.ownerToNFTokenCount[_to] += 1
13
14
15@internal
16def _removeTokenFrom(_from: address, _tokenId: uint256):
17    """
18    @dev Remove a NFT from a given address
19         Throws if `_from` is not the current owner.
20    """
21    # Throws if `_from` is not the current owner
22    assert self.idToOwner[_tokenId] == _from
23    # Change the owner
24    self.idToOwner[_tokenId] = ZERO_ADDRESS
25    # Change count tracking
26    self.ownerToNFTokenCount[_from] -= 1
显示全部
复制

1@internal
2def _clearApproval(_owner: address, _tokenId: uint256):
3    """
4    @dev Clear an approval of a given address
5         Throws if `_owner` is not the current owner.
6    """
7    # Throws if `_owner` is not the current owner
8    assert self.idToOwner[_tokenId] == _owner
9    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
10        # Reset approvals
11        self.idToApprovals[_tokenId] = ZERO_ADDRESS
显示全部
复制

1@internal
2def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
3    """
4    @dev Execute transfer of a NFT.
5         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
6         address for this NFT. (NOTE: `msg.sender` not allowed in private function so pass `_sender`.)
7         Throws if `_to` is the zero address.
8         Throws if `_from` is not the current owner.
9         Throws if `_tokenId` is not a valid NFT.
10    """
显示全部
复制

1    # Check requirements
2    assert self._isApprovedOrOwner(_sender, _tokenId)
3    # Throws if `_to` is the zero address
4    assert _to != ZERO_ADDRESS
5    # Clear approval. Throws if `_from` is not the current owner
6    self._clearApproval(_from, _tokenId)
7    # Remove NFT. Throws if `_tokenId` is not a valid NFT
8    self._removeTokenFrom(_from, _tokenId)
9    # Add NFT
10    self._addTokenTo(_to, _tokenId)
11    # Log the transfer
12    log Transfer(_from, _to, _tokenId)
显示全部
复制

1
2### TRANSFER FUNCTIONS ###
3
4@external
5def transferFrom(_from: address, _to: address, _tokenId: uint256):
6    """
7    @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
8         address for this NFT.
9         Throws if `_from` is not the current owner.
10         Throws if `_to` is the zero address.
11         Throws if `_tokenId` is not a valid NFT.
12    @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
13            they maybe be permanently lost.
14    @param _from The current owner of the NFT.
15    @param _to The new owner.
16    @param _tokenId The NFT to transfer.
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 Transfers the ownership of an NFT from one address to another address.
10         Throws unless `msg.sender` is the current owner, an authorized operator, or the
11         approved address for this NFT.
12         Throws if `_from` is not the current owner.
13         Throws if `_to` is the zero address.
14         Throws if `_tokenId` is not a valid NFT.
15         If `_to` is a smart contract, it calls `onERC721Received` on `_to` and throws if
16         the return value is not `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
17         NOTE: bytes4 is represented by bytes32 with padding
18    @param _from The current owner of the NFT.
19    @param _to The new owner.
20    @param _tokenId The NFT to transfer.
21    @param _data Additional data with no specified format, sent in call to `_to`.
22    """
23    self._transferFrom(_from, _to, _tokenId, msg.sender)
显示全部
复制

1    if _to.is_contract: # check if `_to` is a contract address
复制

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

1        # Throws if transfer destination is a contract which does not implement '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 Set or reaffirm the approved address for an NFT. The zero address indicates there is no approved address.
5         Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.
6         Throws if `_tokenId` is not a valid NFT. (NOTE: This is not written the EIP)
7         Throws if `_approved` is the current owner. (NOTE: This is not written the EIP)
8    @param _approved Address to be approved for the given NFT ID.
9    @param _tokenId ID of the token to be approved.
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # Throws if `_tokenId` is not a valid NFT
13    assert owner != ZERO_ADDRESS
14    # Throws if `_approved` is the current owner
15    assert _approved != owner
显示全部
复制

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

1    # Set the approval
2    self.idToApprovals[_tokenId] = _approved
3    log Approval(owner, _approved, _tokenId)
4
5
6@external
7def setApprovalForAll(_operator: address, _approved: bool):
8    """
9    @dev Enables or disables approval for a third party ("operator") to manage all of
10         `msg.sender`'s assets. It also emits the ApprovalForAll event.
11         Throws if `_operator` is the `msg.sender`. (NOTE: This is not written the EIP)
12    @notice This works even if sender doesn't own any tokens at the time.
13    @param _operator Address to add to the set of authorized operators.
14    @param _approved True if the operators is approved, false to revoke approval.
15    """
16    # Throws if `_operator` is the `msg.sender`
17    assert _operator != msg.sender
18    self.ownerToOperators[msg.sender][_operator] = _approved
19    log ApprovalForAll(msg.sender, _operator, _approved)
显示全部
复制

1### MINT & BURN FUNCTIONS ###
2
3@external
4def mint(_to: address, _tokenId: uint256) -> bool:
复制

1    """
2    @dev Function to mint tokens
3         Throws if `msg.sender` is not the minter.
4         Throws if `_to` is zero address.
5         Throws if `_tokenId` is owned by someone.
6    @param _to The address that will receive the minted tokens.
7    @param _tokenId The token id to mint.
8    @return A boolean that indicates if the operation was successful.
9    """
10    # Throws if `msg.sender` is not the minter
11    assert msg.sender == self.minter
显示全部
复制

1    # Throws if `_to` is zero address
2    assert _to != ZERO_ADDRESS
3    # Add NFT. Throws if `_tokenId` is owned by someone
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 Burns a specific ERC721 token.
6         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
7         address for this NFT.
8         Throws if `_tokenId` is not a valid NFT.
9    @param _tokenId uint256 id of the ERC721 token to be burned.
10    """
11    # Check requirements
12    assert self._isApprovedOrOwner(msg.sender, _tokenId)
13    owner: address = self.idToOwner[_tokenId]
14    # Throws if `_tokenId` is not a valid NFT
15    assert owner != ZERO_ADDRESS
16    self._clearApproval(owner, _tokenId)
17    self._removeTokenFrom(owner, _tokenId)
18    log Transfer(owner, ZERO_ADDRESS, _tokenId)
显示全部
复制