Vyper ERC-721 ஒப்பந்த வழிகாட்டி

1# @dev ERC-721 நான்-பஞ்சிபிள் டோக்கன் (non-fungible token) தரநிலையின் செயலாக்கம்.
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() மூலம் அழைக்கப்படும் ஒப்பந்தத்திற்கான இடைமுகம் (Interface)
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-களும் Transfer நிகழ்வை வெளியிடாமலேயே உருவாக்கப்பட்டு ஒதுக்கப்படலாம். எந்தவொரு
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# முகவரி என்பது அங்கீகரிக்கப்பட்ட முகவரி ஏதுமில்லை என்பதைக் குறிக்கிறது. Transfer நிகழ்வு வெளியிடப்படும்போது, இது
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 உரிமையாளருக்கான ஆபரேட்டர் (operator) செயல்படுத்தப்படும்போது அல்லது முடக்கப்படும்போது இது வெளியிடப்படும். ஆபரேட்டரால்
2# உரிமையாளரின் அனைத்து NFT-களையும் நிர்வகிக்க முடியும்.
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 ID-யிலிருந்து அதைச் சொந்தமாகக் கொண்ட முகவரிக்கான மேப்பிங் (Mapping).
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 டோக்கனை உருவாக்க (mint) கூடிய மின்ட்டரின் (minter) முகவரி
2minter: address
நகலெடு

1# @dev இடைமுக (interface) ID ஆதரிக்கப்படுகிறதா இல்லையா என்பது குறித்த பூலியனுக்கான (bool) மேப்பிங்
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165-இன் ERC165 இடைமுக ID
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC721-இன் ERC165 இடைமுக ID
8ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
நகலெடு

1@external
2def __init__():
நகலெடு

1    # @dev ஒப்பந்த கன்ஸ்ட்ரக்டர் (Contract constructor).
நகலெடு

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    # @dev இடைமுக அடையாளம் ERC-165-இல் குறிப்பிடப்பட்டுள்ளது.
2    @param _interfaceID இடைமுகத்தின் Id
3    return self.supportedInterfaces[_interfaceID]
நகலெடு

1# ## வியூ செயல்பாடுகள் (VIEW FUNCTIONS) ###
நகலெடு

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    # @dev `_owner` வைத்திருக்கும் NFT-களின் எண்ணிக்கையை வழங்கும்.
5         `_owner` பூஜ்ஜிய முகவரியாக இருந்தால் பிழையை ஏற்படுத்தும். பூஜ்ஜிய முகவரிக்கு ஒதுக்கப்பட்ட NFT-கள் செல்லாதவையாகக் கருதப்படும்.
6    @param _owner யாருடைய இருப்பை (balance) வினவ வேண்டுமோ அந்த முகவரி.
7    assert _owner != ZERO_ADDRESS
நகலெடு

1    return self.ownerToNFTokenCount[_owner]
2
3@view
4@external
5def ownerOf(_tokenId: uint256) -> address:
6    # @dev NFT-இன் உரிமையாளர் முகவரியை வழங்கும்.
7         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
8    @param _tokenId ஒரு NFT-க்கான அடையாளங்காட்டி.
9    owner: address = self.idToOwner[_tokenId]
10    # `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
11    assert owner != ZERO_ADDRESS
12    return owner
அனைத்தையும் காட்டு
நகலெடு

1@view
2@external
3def getApproved(_tokenId: uint256) -> address:
4    # @dev ஒரு குறிப்பிட்ட NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரியைப் பெறவும்.
5         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
6    @param _tokenId எந்த NFT-இன் அங்கீகாரத்தை வினவ வேண்டுமோ அதன் ID.
7    # `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
8    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
9    return self.idToApprovals[_tokenId]
அனைத்தையும் காட்டு
நகலெடு

1@view
2@external
3def isApprovedForAll(_owner: address, _operator: address) -> bool:
4    # @dev `_owner`-க்கு `_operator` ஒரு அங்கீகரிக்கப்பட்ட ஆபரேட்டரா என்பதைச் சரிபார்க்கும்.
5    @param _owner NFT-களைச் சொந்தமாகக் கொண்ட முகவரி.
6    @param _operator உரிமையாளரின் சார்பாகச் செயல்படும் முகவரி.
7    return (self.ownerToOperators[_owner])[_operator]
நகலெடு

1
2# ## பரிமாற்ற செயல்பாட்டு உதவியாளர்கள் (TRANSFER FUNCTION HELPERS) ###
3
4@view
5@internal
நகலெடு

1def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
2    # @dev குறிப்பிட்ட டோக்கன் ID-ஐ குறிப்பிட்ட ஸ்பெண்டரால் (spender) பரிமாற்றம் செய்ய முடியுமா என்பதை வழங்கும்
3    @param spender வினவ வேண்டிய ஸ்பெண்டரின் முகவரி
4    @param tokenId பரிமாற்றம் செய்யப்பட வேண்டிய டோக்கனின் uint256 ID
5    @return bool msg.sender குறிப்பிட்ட டோக்கன் ID-க்கு அங்கீகரிக்கப்பட்டவரா,
6        உரிமையாளரின் ஆபரேட்டரா, அல்லது டோக்கனின் உரிமையாளரா என்பது
7    owner: address = self.idToOwner[_tokenId]
8    spenderIsOwner: bool = owner == _spender
9    spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
10    spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
11    return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
அனைத்தையும் காட்டு
நகலெடு

1@internal
2def _addTokenTo(_to: address, _tokenId: uint256):
3    # @dev குறிப்பிட்ட முகவரிக்கு ஒரு NFT-ஐச் சேர்க்கவும்
4         `_tokenId` வேறொருவருக்குச் சொந்தமானதாக இருந்தால் பிழையை ஏற்படுத்தும்.
5    # `_tokenId` வேறொருவருக்குச் சொந்தமானதாக இருந்தால் பிழையை ஏற்படுத்தும்
6    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
7    # உரிமையாளரை மாற்றவும்
8    self.idToOwner[_tokenId] = _to
9    # எண்ணிக்கை கண்காணிப்பை மாற்றவும்
10    self.ownerToNFTokenCount[_to] += 1
11
12
13@internal
14def _removeTokenFrom(_from: address, _tokenId: uint256):
15    # @dev குறிப்பிட்ட முகவரியிலிருந்து ஒரு NFT-ஐ அகற்றவும்
16         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
17    # `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
18    assert self.idToOwner[_tokenId] == _from
19    # உரிமையாளரை மாற்றவும்
20    self.idToOwner[_tokenId] = ZERO_ADDRESS
21    # எண்ணிக்கை கண்காணிப்பை மாற்றவும்
22    self.ownerToNFTokenCount[_from] -= 1
அனைத்தையும் காட்டு
நகலெடு

1@internal
2def _clearApproval(_owner: address, _tokenId: uint256):
3    # @dev குறிப்பிட்ட முகவரியின் அங்கீகாரத்தை அழிக்கவும்
4         `_owner` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
5    # `_owner` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
6    assert self.idToOwner[_tokenId] == _owner
7    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
8        # அங்கீகாரங்களை மீட்டமைக்கவும்
9        self.idToApprovals[_tokenId] = ZERO_ADDRESS
அனைத்தையும் காட்டு
நகலெடு

1@internal
2def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
3    # @dev ஒரு NFT-இன் பரிமாற்றத்தைச் செயல்படுத்தவும்.
4         `msg.sender` தற்போதைய உரிமையாளராகவோ, அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ அல்லது இந்த NFT-க்கான அங்கீகரிக்கப்பட்ட
5         முகவரியாகவோ இல்லாவிட்டால் பிழையை ஏற்படுத்தும். (குறிப்பு: தனிப்பட்ட செயல்பாட்டில் `msg.sender` அனுமதிக்கப்படாது, எனவே `_sender`-ஐ அனுப்பவும்.)
6         `_to` பூஜ்ஜிய முகவரியாக இருந்தால் பிழையை ஏற்படுத்தும்.
7         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
8         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
நகலெடு

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    # பரிமாற்றத்தைப் பதிவு செய்யவும் (Log)
12    log Transfer(_from, _to, _tokenId)
அனைத்தையும் காட்டு
நகலெடு

1
2# ## பரிமாற்ற செயல்பாடுகள் (TRANSFER FUNCTIONS) ###
3
4@external
5def transferFrom(_from: address, _to: address, _tokenId: uint256):
6    # @dev `msg.sender` தற்போதைய உரிமையாளராகவோ, அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ அல்லது இந்த NFT-க்கான அங்கீகரிக்கப்பட்ட
7         முகவரியாகவோ இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
8         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
9         `_to` பூஜ்ஜிய முகவரியாக இருந்தால் பிழையை ஏற்படுத்தும்.
10         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
11    @notice `_to` முகவரி NFT-களைப் பெறும் திறன் கொண்டதா என்பதை உறுதிப்படுத்துவது அழைப்பாளரின் பொறுப்பாகும், இல்லையெனில்
12            அவை நிரந்தரமாக இழக்கப்படலாம்.
13    @param _from NFT-இன் தற்போதைய உரிமையாளர்.
14    @param _to புதிய உரிமையாளர்.
15    @param _tokenId பரிமாற்றம் செய்ய வேண்டிய NFT.
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    # @dev ஒரு NFT-இன் உரிமையை ஒரு முகவரியிலிருந்து மற்றொரு முகவரிக்கு மாற்றும்.
9         `msg.sender` தற்போதைய உரிமையாளராகவோ, அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ அல்லது இந்த NFT-க்கான
10         அங்கீகரிக்கப்பட்ட முகவரியாகவோ இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
11         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
12         `_to` பூஜ்ஜிய முகவரியாக இருந்தால் பிழையை ஏற்படுத்தும்.
13         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
14         `_to` ஒரு ஸ்மார்ட் ஒப்பந்தமாக இருந்தால், அது `_to`-வில் `onERC721Received`-ஐ அழைக்கும், மேலும்
15         திரும்பப் பெறும் மதிப்பு `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
16         குறிப்பு: bytes4 என்பது பேடிங் (padding) உடன் bytes32 மூலம் குறிக்கப்படுகிறது
17    @param _from NFT-இன் தற்போதைய உரிமையாளர்.
18    @param _to புதிய உரிமையாளர்.
19    @param _tokenId பரிமாற்றம் செய்ய வேண்டிய NFT.
20    @param _data `_to`-க்கான அழைப்பில் அனுப்பப்படும், குறிப்பிட்ட வடிவமைப்பு இல்லாத கூடுதல் தரவு.
21    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    # @dev ஒரு NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரியை அமைக்கவும் அல்லது உறுதிப்படுத்தவும். பூஜ்ஜிய முகவரி என்பது அங்கீகரிக்கப்பட்ட முகவரி ஏதுமில்லை என்பதைக் குறிக்கிறது.
4         `msg.sender` தற்போதைய NFT உரிமையாளராகவோ அல்லது தற்போதைய உரிமையாளரின் அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
5         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும். (குறிப்பு: இது EIP-இல் எழுதப்படவில்லை)
6         `_approved` தற்போதைய உரிமையாளராக இருந்தால் பிழையை ஏற்படுத்தும். (குறிப்பு: இது EIP-இல் எழுதப்படவில்லை)
7    @param _approved குறிப்பிட்ட NFT ID-க்கு அங்கீகரிக்கப்பட வேண்டிய முகவரி.
8    @param _tokenId அங்கீகரிக்கப்பட வேண்டிய டோக்கனின் ID.
9    owner: address = self.idToOwner[_tokenId]
10    # `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
11    assert owner != ZERO_ADDRESS
12    # `_approved` தற்போதைய உரிமையாளராக இருந்தால் பிழையை ஏற்படுத்தும்
13    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    # @dev `msg.sender`-இன் அனைத்து சொத்துகளையும் நிர்வகிக்க மூன்றாம் தரப்பினருக்கான ("ஆபரேட்டர்") அங்கீகாரத்தைச் செயல்படுத்துகிறது அல்லது முடக்குகிறது.
9         இது ApprovalForAll நிகழ்வையும் வெளியிடுகிறது.
10         `_operator` என்பது `msg.sender` ஆக இருந்தால் பிழையை ஏற்படுத்தும். (குறிப்பு: இது EIP-இல் எழுதப்படவில்லை)
11    @notice அந்த நேரத்தில் அனுப்புநரிடம் எந்த டோக்கன்களும் இல்லாவிட்டாலும் இது செயல்படும்.
12    @param _operator அங்கீகரிக்கப்பட்ட ஆபரேட்டர்களின் தொகுப்பில் சேர்க்க வேண்டிய முகவரி.
13    @param _approved ஆபரேட்டர்கள் அங்கீகரிக்கப்பட்டால் True, அங்கீகாரத்தைத் திரும்பப் பெற False.
14    # `_operator` என்பது `msg.sender` ஆக இருந்தால் பிழையை ஏற்படுத்தும்
15    assert _operator != msg.sender
16    self.ownerToOperators[msg.sender][_operator] = _approved
17    log ApprovalForAll(msg.sender, _operator, _approved)
அனைத்தையும் காட்டு
நகலெடு

1# ## மின்ட் மற்றும் பர்ன் செயல்பாடுகள் (MINT & BURN FUNCTIONS) ###
2
3@external
4def mint(_to: address, _tokenId: uint256) -> bool:
நகலெடு

1    # @dev டோக்கன்களை உருவாக்குவதற்கான (mint) செயல்பாடு
2         `msg.sender` மின்ட்டராக (minter) இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
3         `_to` பூஜ்ஜிய முகவரியாக இருந்தால் பிழையை ஏற்படுத்தும்.
4         `_tokenId` வேறொருவருக்குச் சொந்தமானதாக இருந்தால் பிழையை ஏற்படுத்தும்.
5    @param _to உருவாக்கப்பட்ட டோக்கன்களைப் பெறும் முகவரி.
6    @param _tokenId உருவாக்க வேண்டிய டோக்கன் id.
7    @return செயல்பாடு வெற்றிகரமாக நடந்ததா என்பதைக் குறிக்கும் பூலியன் (boolean).
8    # `msg.sender` மின்ட்டராக (minter) இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
9    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    # @dev ஒரு குறிப்பிட்ட ERC721 டோக்கனை அழிக்கும் (Burn).
5         `msg.sender` தற்போதைய உரிமையாளராகவோ, அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ அல்லது இந்த NFT-க்கான அங்கீகரிக்கப்பட்ட
6         முகவரியாகவோ இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
7         `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்.
8    @param _tokenId அழிக்கப்பட வேண்டிய ERC721 டோக்கனின் uint256 id.
9    # தேவைகளைச் சரிபார்க்கவும்
10    assert self._isApprovedOrOwner(msg.sender, _tokenId)
11    owner: address = self.idToOwner[_tokenId]
12    # `_tokenId` சரியான NFT ஆக இல்லாவிட்டால் பிழையை ஏற்படுத்தும்
13    assert owner != ZERO_ADDRESS
14    self._clearApproval(owner, _tokenId)
15    self._removeTokenFrom(owner, _tokenId)
16    log Transfer(owner, ZERO_ADDRESS, _tokenId)
அனைத்தையும் காட்டு
நகலெடு