Panduan Kontrak ERC-721 Vyper

# @dev Emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are # @dev Memancarkan saat kepemilikan NFT apa pun berubah melalui mekanisme apa pun. Event ini memancarkan saat NFT
#      created (`from` == 0) and destroyed (`to` == 0). Exception: during contract creation, any # dibuat (`from` == 0) dan dihancurkan (`to` == 0). Pengecualian: selama pembuatan kontrak, sejumlah
#      number of NFTs may be created and assigned without emitting Transfer. At the time of any # NFT dapat dibuat dan ditetapkan tanpa memancarkan Transfer. Pada saat
#      transfer, the approved address for that NFT (if any) is reset to none. # transfer apa pun, alamat yang disetujui untuk NFT tersebut (jika ada) diatur ulang menjadi tidak ada.
# @param _from Sender of NFT (if address is zero address it indicates token creation). # @param _from Pengirim NFT (jika alamat adalah alamat nol, ini menunjukkan pembuatan token).
# @param _to Receiver of NFT (if address is zero address it indicates token destruction). # @param _to Penerima NFT (jika alamat adalah alamat nol, ini menunjukkan penghancuran token).
# @param _tokenId The NFT that got transferred. # @param _tokenId NFT yang ditransfer.
event Transfer:
    sender: indexed(address)
    receiver: indexed(address)
    tokenId: indexed(uint256)

# @dev This emits when the approved address for an NFT is changed or reaffirmed. The zero # @dev Ini memancarkan saat alamat yang disetujui untuk NFT diubah atau ditegaskan kembali. Alamat
#      address indicates there is no approved address. When a Transfer event emits, this also # nol menunjukkan tidak ada alamat yang disetujui. Saat event Transfer memancarkan, ini juga
#      indicates that the approved address for that NFT (if any) is reset to none. # menunjukkan bahwa alamat yang disetujui untuk NFT tersebut (jika ada) diatur ulang menjadi tidak ada.
# @param _owner Owner of NFT. # @param _owner Pemilik NFT.
# @param _approved Address that we are approving. # @param _approved Alamat yang kami setujui.
# @param _tokenId NFT which we are approving. # @param _tokenId NFT yang kami setujui.
event Approval:
    owner: indexed(address)
    approved: indexed(address)
    tokenId: indexed(uint256)

# @dev This emits when an operator is enabled or disabled for an owner. The operator can manage # @dev Ini memancarkan saat operator diaktifkan atau dinonaktifkan untuk pemilik. Operator dapat mengelola
#      all NFTs of the owner. # semua NFT milik pemilik.
# @param _owner Owner of NFT. # @param _owner Pemilik NFT.
# @param _operator Address to which we are setting operator rights. # @param _operator Alamat yang kami tetapkan hak operatornya.
# @param _approved Status of operator rights(true if operator rights are given and false if # @param _approved Status hak operator (true jika hak operator diberikan dan false jika
# revoked). # dicabut).
event ApprovalForAll:
    owner: indexed(address)
    operator: indexed(address)
    approved: bool

@view
@external
def balanceOf(_owner: address) -> uint256:
    # @dev Mengembalikan jumlah NFT yang dimiliki oleh `_owner`.
         Melempar kesalahan jika `_owner` adalah alamat nol. NFT yang ditetapkan ke alamat nol dianggap tidak valid.
    @param _owner Alamat untuk menanyakan saldo.
    """
    @dev Returns the number of NFTs owned by `_owner`.
         Throws if `_owner` is the zero address. NFTs assigned to the zero address are considered invalid.
    @param _owner Address for whom to query the balance.
    """
    assert _owner != ZERO_ADDRESS

    return self.ownerToNFTokenCount[_owner]

@view
@external
def ownerOf(_tokenId: uint256) -> address:
    # @dev Mengembalikan alamat pemilik NFT.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
    @param _tokenId Pengidentifikasi untuk NFT.
    """
    @dev Returns the address of the owner of the NFT.
         Throws if `_tokenId` is not a valid NFT.
    @param _tokenId The identifier for an NFT.
    """
    owner: address = self.idToOwner[_tokenId]
    # Throws if `_tokenId` is not a valid NFT # Melempar kesalahan jika `_tokenId` bukan NFT yang valid
    assert owner != ZERO_ADDRESS
    return owner

@view
@external
def getApproved(_tokenId: uint256) -> address:
    # @dev Dapatkan alamat yang disetujui untuk satu NFT.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
    @param _tokenId ID NFT untuk menanyakan persetujuannya.
    """
    @dev Get the approved address for a single NFT.
         Throws if `_tokenId` is not a valid NFT.
    @param _tokenId ID of the NFT to query the approval of.
    """
    # Throws if `_tokenId` is not a valid NFT # Melempar kesalahan jika `_tokenId` bukan NFT yang valid
    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
    return self.idToApprovals[_tokenId]

@view
@external
def isApprovedForAll(_owner: address, _operator: address) -> bool:
    # @dev Memeriksa apakah `_operator` adalah operator yang disetujui untuk `_owner`.
    @param _owner Alamat yang memiliki NFT.
    @param _operator Alamat yang bertindak atas nama pemilik.
    """
    @dev Checks if `_operator` is an approved operator for `_owner`.
    @param _owner The address that owns the NFTs.
    @param _operator The address that acts on behalf of the owner.
    """
    return (self.ownerToOperators[_owner])[_operator]

def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
    # @dev Mengembalikan apakah pembelanja yang diberikan dapat mentransfer ID token yang diberikan
    @param spender alamat pembelanja untuk ditanyakan
    @param tokenId uint256 ID token yang akan ditransfer
    @return bool apakah msg.sender disetujui untuk ID token yang diberikan,
        adalah operator dari pemilik, atau adalah pemilik token
    """
    @dev Returns whether the given spender can transfer a given token ID
    @param spender address of the spender to query
    @param tokenId uint256 ID of the token to be transferred
    @return bool whether the msg.sender is approved for the given token ID,
        is an operator of the owner, or is the owner of the token
    """
    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 Tambahkan NFT ke alamat yang diberikan
         Melempar kesalahan jika `_tokenId` dimiliki oleh seseorang.
    """
    @dev Add a NFT to a given address
         Throws if `_tokenId` is owned by someone.
    """
    # Throws if `_tokenId` is owned by someone # Melempar kesalahan jika `_tokenId` dimiliki oleh seseorang
    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
    # Change the owner # Ubah pemilik
    self.idToOwner[_tokenId] = _to
    # Change count tracking # Ubah pelacakan jumlah
    self.ownerToNFTokenCount[_to] += 1


@internal
def _removeTokenFrom(_from: address, _tokenId: uint256):
    # @dev Hapus NFT dari alamat yang diberikan
         Melempar kesalahan jika `_from` bukan pemilik saat ini.
    """
    @dev Remove a NFT from a given address
         Throws if `_from` is not the current owner.
    """
    # Throws if `_from` is not the current owner # Melempar kesalahan jika `_from` bukan pemilik saat ini
    assert self.idToOwner[_tokenId] == _from
    # Change the owner # Ubah pemilik
    self.idToOwner[_tokenId] = ZERO_ADDRESS
    # Change count tracking # Ubah pelacakan jumlah
    self.ownerToNFTokenCount[_from] -= 1

@internal
def _clearApproval(_owner: address, _tokenId: uint256):
    # @dev Hapus persetujuan dari alamat yang diberikan
         Melempar kesalahan jika `_owner` bukan pemilik saat ini.
    """
    @dev Clear an approval of a given address
         Throws if `_owner` is not the current owner.
    """
    # Throws if `_owner` is not the current owner # Melempar kesalahan jika `_owner` bukan pemilik saat ini
    assert self.idToOwner[_tokenId] == _owner
    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
        # Reset approvals # Atur ulang persetujuan
        self.idToApprovals[_tokenId] = ZERO_ADDRESS

@internal
def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
    # @dev Eksekusi transfer NFT.
         Melempar kesalahan kecuali `msg.sender` adalah pemilik saat ini, operator yang berwenang, atau alamat
         yang disetujui untuk NFT ini. (CATATAN: `msg.sender` tidak diizinkan dalam fungsi privat jadi teruskan `_sender`.)
         Melempar kesalahan jika `_to` adalah alamat nol.
         Melempar kesalahan jika `_from` bukan pemilik saat ini.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
    """
    @dev Execute transfer of a NFT.
         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
         address for this NFT. (NOTE: `msg.sender` not allowed in private function so pass `_sender`.)
         Throws if `_to` is the zero address.
         Throws if `_from` is not the current owner.
         Throws if `_tokenId` is not a valid NFT.
    """

    # Check requirements # Periksa persyaratan
    assert self._isApprovedOrOwner(_sender, _tokenId)
    # Throws if `_to` is the zero address # Melempar kesalahan jika `_to` adalah alamat nol
    assert _to != ZERO_ADDRESS
    # Clear approval. Throws if `_from` is not the current owner # Hapus persetujuan. Melempar kesalahan jika `_from` bukan pemilik saat ini
    self._clearApproval(_from, _tokenId)
    # Remove NFT. Throws if `_tokenId` is not a valid NFT # Hapus NFT. Melempar kesalahan jika `_tokenId` bukan NFT yang valid
    self._removeTokenFrom(_from, _tokenId)
    # Add NFT # Tambahkan NFT
    self._addTokenTo(_to, _tokenId)
    # Log the transfer # Catat transfer
    log Transfer(_from, _to, _tokenId)

### TRANSFER FUNCTIONS ### # ## FUNGSI TRANSFER ###

@external
def transferFrom(_from: address, _to: address, _tokenId: uint256):
    # @dev Melempar kesalahan kecuali `msg.sender` adalah pemilik saat ini, operator yang berwenang, atau alamat
         yang disetujui untuk NFT ini.
         Melempar kesalahan jika `_from` bukan pemilik saat ini.
         Melempar kesalahan jika `_to` adalah alamat nol.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
    @notice Pemanggil bertanggung jawab untuk mengonfirmasi bahwa `_to` mampu menerima NFT atau jika tidak
            mereka mungkin hilang secara permanen.
    @param _from Pemilik NFT saat ini.
    @param _to Pemilik baru.
    @param _tokenId NFT yang akan ditransfer.
    """
    @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
         address for this NFT.
         Throws if `_from` is not the current owner.
         Throws if `_to` is the zero address.
         Throws if `_tokenId` is not a valid NFT.
    @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
            they maybe be permanently lost.
    @param _from The current owner of the NFT.
    @param _to The new owner.
    @param _tokenId The NFT to transfer.
    """
    self._transferFrom(_from, _to, _tokenId, msg.sender)

@external
def safeTransferFrom(
        _from: address,
        _to: address,
        _tokenId: uint256,
        _data: Bytes[1024]=b""
    ):
    # @dev Mentransfer kepemilikan NFT dari satu alamat ke alamat lain.
         Melempar kesalahan kecuali `msg.sender` adalah pemilik saat ini, operator yang berwenang, atau
         alamat yang disetujui untuk NFT ini.
         Melempar kesalahan jika `_from` bukan pemilik saat ini.
         Melempar kesalahan jika `_to` adalah alamat nol.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
         Jika `_to` adalah smart contract, ia memanggil `onERC721Received` pada `_to` dan melempar kesalahan jika
         nilai kembaliannya bukan `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
         CATATAN: bytes4 diwakili oleh bytes32 dengan padding
    @param _from Pemilik NFT saat ini.
    @param _to Pemilik baru.
    @param _tokenId NFT yang akan ditransfer.
    @param _data Data tambahan tanpa format yang ditentukan, dikirim dalam panggilan ke `_to`.
    """
    @dev Transfers the ownership of an NFT from one address to another address.
         Throws unless `msg.sender` is the current owner, an authorized operator, or the
         approved address for this NFT.
         Throws if `_from` is not the current owner.
         Throws if `_to` is the zero address.
         Throws if `_tokenId` is not a valid NFT.
         If `_to` is a smart contract, it calls `onERC721Received` on `_to` and throws if
         the return value is not `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
         NOTE: bytes4 is represented by bytes32 with padding
    @param _from The current owner of the NFT.
    @param _to The new owner.
    @param _tokenId The NFT to transfer.
    @param _data Additional data with no specified format, sent in call to `_to`.
    """
    self._transferFrom(_from, _to, _tokenId, msg.sender)

@external
def approve(_approved: address, _tokenId: uint256):
    # @dev Tetapkan atau tegaskan kembali alamat yang disetujui untuk NFT. Alamat nol menunjukkan tidak ada alamat yang disetujui.
         Melempar kesalahan kecuali `msg.sender` adalah pemilik NFT saat ini, atau operator yang berwenang dari pemilik saat ini.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid. (CATATAN: Ini tidak ditulis di EIP)
         Melempar kesalahan jika `_approved` adalah pemilik saat ini. (CATATAN: Ini tidak ditulis di EIP)
    @param _approved Alamat yang akan disetujui untuk ID NFT yang diberikan.
    @param _tokenId ID token yang akan disetujui.
    """
    @dev Set or reaffirm the approved address for an NFT. The zero address indicates there is no approved address.
         Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.
         Throws if `_tokenId` is not a valid NFT. (NOTE: This is not written the EIP)
         Throws if `_approved` is the current owner. (NOTE: This is not written the EIP)
    @param _approved Address to be approved for the given NFT ID.
    @param _tokenId ID of the token to be approved.
    """
    owner: address = self.idToOwner[_tokenId]
    # Throws if `_tokenId` is not a valid NFT # Melempar kesalahan jika `_tokenId` bukan NFT yang valid
    assert owner != ZERO_ADDRESS
    # Throws if `_approved` is the current owner # Melempar kesalahan jika `_approved` adalah pemilik saat ini
    assert _approved != owner

    # Set the approval # Tetapkan persetujuan
    self.idToApprovals[_tokenId] = _approved
    log Approval(owner, _approved, _tokenId)


@external
def setApprovalForAll(_operator: address, _approved: bool):
    # @dev Mengaktifkan atau menonaktifkan persetujuan untuk pihak ketiga ("operator") untuk mengelola semua
         aset `msg.sender`. Ini juga memancarkan event ApprovalForAll.
         Melempar kesalahan jika `_operator` adalah `msg.sender`. (CATATAN: Ini tidak ditulis di EIP)
    @notice Ini berfungsi bahkan jika pengirim tidak memiliki token apa pun pada saat itu.
    @param _operator Alamat untuk ditambahkan ke kumpulan operator yang berwenang.
    @param _approved True jika operator disetujui, false untuk mencabut persetujuan.
    """
    @dev Enables or disables approval for a third party ("operator") to manage all of
         `msg.sender`'s assets. It also emits the ApprovalForAll event.
         Throws if `_operator` is the `msg.sender`. (NOTE: This is not written the EIP)
    @notice This works even if sender doesn't own any tokens at the time.
    @param _operator Address to add to the set of authorized operators.
    @param _approved True if the operators is approved, false to revoke approval.
    """
    # Throws if `_operator` is the `msg.sender` # Melempar kesalahan jika `_operator` adalah `msg.sender`
    assert _operator != msg.sender
    self.ownerToOperators[msg.sender][_operator] = _approved
    log ApprovalForAll(msg.sender, _operator, _approved)

    # @dev Fungsi untuk melakukan mint token
         Melempar kesalahan jika `msg.sender` bukan minter.
         Melempar kesalahan jika `_to` adalah alamat nol.
         Melempar kesalahan jika `_tokenId` dimiliki oleh seseorang.
    @param _to Alamat yang akan menerima token yang di-mint.
    @param _tokenId Id token untuk di-mint.
    @return Boolean yang menunjukkan apakah operasi berhasil.
    """
    @dev Function to mint tokens
         Throws if `msg.sender` is not the minter.
         Throws if `_to` is zero address.
         Throws if `_tokenId` is owned by someone.
    @param _to The address that will receive the minted tokens.
    @param _tokenId The token id to mint.
    @return A boolean that indicates if the operation was successful.
    """
    # Throws if `msg.sender` is not the minter # Melempar kesalahan jika `msg.sender` bukan minter
    assert msg.sender == self.minter

@external
def burn(_tokenId: uint256):
    # @dev Membakar token ERC721 tertentu.
         Melempar kesalahan kecuali `msg.sender` adalah pemilik saat ini, operator yang berwenang, atau alamat
         yang disetujui untuk NFT ini.
         Melempar kesalahan jika `_tokenId` bukan NFT yang valid.
    @param _tokenId uint256 id dari token ERC721 yang akan dibakar.
    """
    @dev Burns a specific ERC721 token.
         Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
         address for this NFT.
         Throws if `_tokenId` is not a valid NFT.
    @param _tokenId uint256 id of the ERC721 token to be burned.
    """
    # Check requirements # Periksa persyaratan
    assert self._isApprovedOrOwner(msg.sender, _tokenId)
    owner: address = self.idToOwner[_tokenId]
    # Throws if `_tokenId` is not a valid NFT # Melempar kesalahan jika `_tokenId` bukan NFT yang valid
    assert owner != ZERO_ADDRESS
    self._clearApproval(owner, _tokenId)
    self._removeTokenFrom(owner, _tokenId)
    log Transfer(owner, ZERO_ADDRESS, _tokenId)