Vyper ERC-721 కాంట్రాక్ట్ వాక్‌త్రూ

1# @dev ERC-721 నాన్-ఫంగిబుల్ టోకెన్ ప్రమాణం యొక్క అమలు.
2# @రచయిత ర్యూయా నకమురా (@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 యాజమాన్యం మారినప్పుడు విడుదల అవుతుంది. NFTలు సృష్టించబడినప్పుడు ఈ ఈవెంట్ విడుదల అవుతుంది
2#      (`from` == 0) మరియు నాశనం చేయబడినప్పుడు (`to` == 0). మినహాయింపు: కాంట్రాక్ట్ సృష్టి సమయంలో, ఏదైనా
3#      బదిలీని విడుదల చేయకుండా NFTల సంఖ్యను సృష్టించవచ్చు మరియు కేటాయించవచ్చు. ఏదైనా సమయంలో
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#      యజమాని యొక్క అన్ని NFTలు.
3# @param _owner NFT యజమాని.
4# @param _operator మేము ఆపరేటర్ హక్కులను సెట్ చేస్తున్న చిరునామా.
5# @param _approved ఆపరేటర్ హక్కుల స్థితి (ఆపరేటర్ హక్కులు ఇస్తే నిజం మరియు కాకపోతే తప్పు
6# రద్దు చేయబడింది).
7event ApprovalForAll:
8    owner: indexed(address)
9    operator: indexed(address)
10    approved: bool
అన్నీ చూపించు
కాపీ

1# @dev NFT ID నుండి దాని యజమాని అయిన చిరునామాకు మ్యాపింగ్.
2idToOwner: HashMap[uint256, address]
3
4# @dev NFT ID నుండి ఆమోదించబడిన చిరునామాకు మ్యాపింగ్.
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### వ్యూ ఫంక్షన్లు ###
2
కాపీ

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev `_owner` యాజమాన్యంలోని NFTల సంఖ్యను తిరిగి ఇస్తుంది.
6         `_owner` సున్నా చిరునామా అయితే త్రో చేస్తుంది. సున్నా చిరునామాకు కేటాయించబడిన NFTలు చెల్లనివిగా పరిగణించబడతాయి.
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 `_owner` కోసం `_operator` ఆమోదించబడిన ఆపరేటర్ కాదా అని తనిఖీ చేస్తుంది.
6    @param _owner NFTల యాజమాన్యంలోని చిరునామా.
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    # `_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కి ఆమోదించబడిన చిరునామా కాకపోతే త్రో చేస్తుంది. (గమనిక: ప్రైవేట్ ఫంక్షన్‌లో `msg.sender` అనుమతించబడదు కాబట్టి `_sender`ను పాస్ చేయండి.)
6         `_to` సున్నా చిరునామా అయితే త్రో చేస్తుంది.
7         `_from` ప్రస్తుత యజమాని కాకపోతే త్రో చేస్తుంది.
8         `_tokenId` చెల్లుబాటు అయ్యే NFT కాకపోతే త్రో చేస్తుంది.
9    """
అన్నీ చూపించు
కాపీ

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### 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` NFTలను స్వీకరించగలదని నిర్ధారించుకోవాల్సిన బాధ్యత కాలర్‌పై ఉంటుంది, లేకపోతే
12            అవి శాశ్వతంగా కోల్పోవచ్చు.
13    @param _from NFT యొక్క ప్రస్తుత యజమాని.
14    @param _to కొత్త యజమాని.
15    @param _tokenId బదిలీ చేయవలసిన NFT.
16    """
17    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` ప్రస్తుత యజమాని, అధీకృత ఆపరేటర్ లేదా ఈ
11         NFTకి ఆమోదించబడిన చిరునామా కాకపోతే త్రో చేస్తుంది.
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 ఆపరేటర్ ఆమోదించబడితే నిజం, ఆమోదాన్ని రద్దు చేయడానికి తప్పు.
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### 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    # `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` ప్రస్తుత యజమాని, అధీకృత ఆపరేటర్ లేదా ఈ
7         NFTకి ఆమోదించబడిన చిరునామా కాకపోతే త్రో చేస్తుంది.
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)
అన్నీ చూపించు
కాపీ