वाइपर ERC-721 अनुबंध वॉकथ्रू

1# @dev ERC-721 नॉन-फंजिबल टोकन मानक का कार्यान्वयन।
2# @author रयुया नाकामुरा (@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 का स्वामित्व बदलने पर उत्सर्जित होता है। यह इवेंट तब उत्सर्जित होता है जब NFTs बनाए जाते हैं (`from` == 0) और नष्ट हो जाते हैं (`to` == 0)। अपवाद: अनुबंध निर्माण के दौरान, बिना Transfer उत्सर्जित किए किसी भी संख्या में NFTs बनाए और असाइन किए जा सकते हैं। किसी भी हस्तांतरण के समय, उस NFT के लिए स्वीकृत पता (यदि कोई हो) रीसेट हो जाता है।
2# @param _from NFT का प्रेषक (यदि पता शून्य पता है तो यह टोकन निर्माण को इंगित करता है)।
3# @param _to NFT का रिसीवर (यदि पता शून्य पता है तो यह टोकन विनाश को इंगित करता है)।
4# @param _tokenId वह NFT जिसे स्थानांतरित किया गया था।
5event Transfer:
6    sender: indexed(address)
7    receiver: indexed(address)
8    tokenId: indexed(uint256)
कॉपी करें

1# @dev यह तब उत्सर्जित होता है जब किसी NFT के लिए स्वीकृत पता बदल दिया जाता है या उसकी पुष्टि की जाती है। शून्य पता इंगित करता है कि कोई स्वीकृत पता नहीं है। जब एक Transfer इवेंट उत्सर्जित होता है, तो यह यह भी इंगित करता है कि उस NFT के लिए स्वीकृत पता (यदि कोई हो) रीसेट हो जाता है।
2# @param _owner NFT का स्वामी।
3# @param _approved पता जिसे हम स्वीकृत कर रहे हैं।
4# @param _tokenId NFT जिसे हम स्वीकृत कर रहे हैं।
5event Approval:
6    owner: indexed(address)
7    approved: indexed(address)
8    tokenId: indexed(uint256)
कॉपी करें

1# @dev यह तब उत्सर्जित होता है जब किसी मालिक के लिए एक ऑपरेटर सक्षम या अक्षम होता है। ऑपरेटर मालिक के सभी NFTs का प्रबंधन कर सकता है।
2# @param _owner NFT का स्वामी।
3# @param _operator पता जिस पर हम ऑपरेटर अधिकार सेट कर रहे हैं।
4# @param _approved ऑपरेटर अधिकारों की स्थिति (सही यदि ऑपरेटर अधिकार दिए गए हैं और गलत यदि रद्द कर दिए गए हैं)।
5event ApprovalForAll:
6    owner: indexed(address)
7    operator: indexed(address)
8    approved: bool
कॉपी करें

1# @dev NFT आईडी से उस पते पर मैपिंग जो इसका मालिक है।
2idToOwner: HashMap[uint256, address]
3
4# @dev NFT आईडी से स्वीकृत पते पर मैपिंग।
5idToApprovals: HashMap[uint256, address]
कॉपी करें

1# @dev मालिक के पते से उसके टोकन की गिनती तक मैपिंग।
2ownerToNFTokenCount: HashMap[address, uint256]
कॉपी करें

1# @dev मालिक के पते से ऑपरेटर पतों की मैपिंग तक मैपिंग।
2ownerToOperators: HashMap[address, HashMap[address, bool]]
कॉपी करें

1# @dev मिंटर का पता, जो एक टोकन मिंट कर सकता है
2minter: address
कॉपी करें

1# @dev इंटरफ़ेस आईडी से बूल तक मैपिंग कि यह समर्थित है या नहीं
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165 का ERC165 इंटरफ़ेस आईडी
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC721 का ERC165 इंटरफ़ेस आईडी
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 इंटरफ़ेस का आईडी
4    """
5    return self.supportedInterfaces[_interfaceID]
कॉपी करें

1### VIEW FUNCTIONS ###
2
कॉपी करें

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev `_owner` के स्वामित्व वाले NFTs की संख्या लौटाता है।
6         यदि `_owner` शून्य पता है तो फेंकता है। शून्य पते को सौंपे गए NFTs को अमान्य माना जाता है।
7    @param _owner पता जिसके लिए शेष राशि की क्वेरी करनी है।
8    """
कॉपी करें

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    # 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 एक एकल NFT के लिए स्वीकृत पता प्राप्त करें।
6         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
7    @param _tokenId NFT की आईडी जिसकी स्वीकृति की क्वेरी करनी है।
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 जांचता है कि `_operator` `_owner` के लिए एक स्वीकृत ऑपरेटर है या नहीं।
6    @param _owner वह पता जो NFTs का मालिक है।
7    @param _operator वह पता जो मालिक की ओर से कार्य करता है।
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 लौटाता है कि दिया गया खर्च करने वाला किसी दिए गए टोकन आईडी को स्थानांतरित कर सकता है या नहीं
4    @param spender क्वेरी करने के लिए खर्च करने वाले का पता
5    @param tokenId स्थानांतरित किए जाने वाले टोकन की uint256 आईडी
6    @return bool कि msg.sender दिए गए टोकन आईडी के लिए स्वीकृत है या नहीं,
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    # 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 दिए गए पते से एक NFT हटाएं
19         यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
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 दिए गए पते की स्वीकृति साफ़ करें
5         यदि `_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 NFT का स्थानांतरण निष्पादित करें।
5         जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है। (नोट: निजी फ़ंक्शन में `msg.sender` की अनुमति नहीं है इसलिए `_sender` पास करें।)
6         यदि `_to` शून्य पता है तो फेंकता है।
7         यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
8         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
9    """
सभी दिखाएँकॉपी करें

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 जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है।
8         यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
9         यदि `_to` शून्य पता है तो फेंकता है।
10         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
11    @notice कॉलर यह पुष्टि करने के लिए ज़िम्मेदार है कि `_to` NFTs प्राप्त करने में सक्षम है अन्यथा वे स्थायी रूप से खो सकते हैं।
12    @param _from NFT का वर्तमान स्वामी।
13    @param _to नया स्वामी।
14    @param _tokenId स्थानांतरित करने के लिए NFT।
15    """
16    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         यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
12         यदि `_to` शून्य पता है तो फेंकता है।
13         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
14         यदि `_to` एक स्मार्ट अनुबंध है, तो यह `_to` पर `onERC721Received` को कॉल करता है और यदि वापसी मान `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` नहीं है तो फेंकता है।
15         नोट: bytes4 को पैडिंग के साथ bytes32 द्वारा दर्शाया गया है
16    @param _from NFT का वर्तमान स्वामी।
17    @param _to नया स्वामी।
18    @param _tokenId स्थानांतरित करने के लिए NFT।
19    @param _data बिना किसी निर्दिष्ट प्रारूप के अतिरिक्त डेटा, `_to` पर कॉल में भेजा गया।
20    """
21    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 किसी NFT के लिए स्वीकृत पता सेट करें या उसकी पुष्टि करें। शून्य पता इंगित करता है कि कोई स्वीकृत पता नहीं है।
5         जब तक `msg.sender` वर्तमान NFT स्वामी, या वर्तमान स्वामी का अधिकृत ऑपरेटर न हो, तब तक फेंकता है।
6         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
7         यदि `_approved` वर्तमान स्वामी है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
8    @param _approved दिए गए NFT आईडी के लिए स्वीकृत किए जाने वाला पता।
9    @param _tokenId स्वीकृत किए जाने वाले टोकन की आईडी।
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 किसी तीसरे पक्ष ("ऑपरेटर") के लिए `msg.sender` की सभी संपत्तियों का प्रबंधन करने के लिए अनुमोदन को सक्षम या अक्षम करता है। यह ApprovalForAll इवेंट भी उत्सर्जित करता है।
10         यदि `_operator` `msg.sender` है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
11    @notice यह तब भी काम करता है जब प्रेषक के पास उस समय कोई टोकन न हो।
12    @param _operator अधिकृत ऑपरेटरों के सेट में जोड़ने के लिए पता।
13    @param _approved यदि ऑपरेटर स्वीकृत है तो सही, अनुमोदन रद्द करने के लिए गलत।
14    """
15    # Throws if `_operator` is the `msg.sender`
16    assert _operator != msg.sender
17    self.ownerToOperators[msg.sender][_operator] = _approved
18    log ApprovalForAll(msg.sender, _operator, _approved)
सभी दिखाएँकॉपी करें

1### MINT & BURN FUNCTIONS ###
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 मिंट करने के लिए टोकन आईडी।
8    @return एक बूलियन जो इंगित करता है कि ऑपरेशन सफल था या नहीं।
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 एक विशिष्ट ERC721 टोकन को बर्न करता है।
6         जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है।
7         यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
8    @param _tokenId uint256 बर्न किए जाने वाले ERC721 टोकन की आईडी।
9    """
10    # Check requirements
11    assert self._isApprovedOrOwner(msg.sender, _tokenId)
12    owner: address = self.idToOwner[_tokenId]
13    # Throws if `_tokenId` is not a valid NFT
14    assert owner != ZERO_ADDRESS
15    self._clearApproval(owner, _tokenId)
16    self._removeTokenFrom(owner, _tokenId)
17    log Transfer(owner, ZERO_ADDRESS, _tokenId)
सभी दिखाएँकॉपी करें