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 ची मालकी कोणत्याही यंत्रणेद्वारे बदलल्यावर उत्सर्जित होते. हा इव्हेंट NFTs
2#      तयार झाल्यावर (`from` == 0) आणि नष्ट झाल्यावर (`to` == 0) उत्सर्जित होतो. अपवाद: कॉन्ट्रॅक्ट निर्मिती दरम्यान, कितीही
3#      NFTs ट्रान्सफर उत्सर्जित न करता तयार आणि नियुक्त केले जाऊ शकतात. कोणत्याही
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#      पत्ता सूचित करतो की कोणताही मंजूर पत्ता नाही. जेव्हा एखादा ट्रान्सफर इव्हेंट उत्सर्जित होतो, तेव्हा हे देखील
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#      मालकाच्या सर्व NFTs चे व्यवस्थापन करू शकतो.
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 आयडी वरून त्याच्या मालकाच्या पत्त्यावर मॅपिंग.
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 इंटरफेस आयडी वरून ते समर्थित आहे की नाही याबद्दलच्या bool वर मॅपिंग
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### व्ह्यू फंक्शन्स ###
2
कॉपी

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev `_owner` च्या मालकीच्या NFTs ची संख्या परत करते.
6         `_owner` शून्य पत्ता असल्यास थ्रो करते. शून्य पत्त्याला नियुक्त केलेले NFTs अवैध मानले जातात.
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 च्या मंजुरीची चौकशी करायची आहे त्याचा आयडी.
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 NFTs चा मालक असलेला पत्ता.
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 दिलेला स्पेंडर दिलेला टोकन आयडी हस्तांतरित करू शकतो की नाही हे परत करते
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    # `_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` NFTs प्राप्त करण्यास सक्षम आहे याची पुष्टी करण्याची जबाबदारी कॉलरची आहे अन्यथा
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 आयडीसाठी मंजूर करायचा पत्ता.
9    @param _tokenId मंजूर करायच्या टोकनचा आयडी.
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 तृतीय पक्षासाठी ('ऑपरेटर') `msg.sender` च्या सर्व मालमत्तेचे व्यवस्थापन
10         करण्यासाठी मंजुरी सक्षम किंवा अक्षम करते. हे 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 मिंट करायचा टोकन आयडी.
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 आयडी.
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)
सर्व दाखवा
कॉपी