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

Vyper

erc-721

Python

தொடக்கநிலை

ஓரி பொமரன்ட்ஸ்

1 ஏப்ரல், 2021

16 நிமிட வாசிப்பு

அறிமுகம்

ERC-721 தரநிலையானது பூஞ்சையற்ற வில்லைகளின் (Non-Fungible Tokens - NFT) உரிமையைக் கொண்டிருக்கப் பயன்படுகிறது. தனிப்பட்ட வில்லைகளுக்கு இடையே எந்த வித்தியாசமும் இல்லாததால், ERC-20 வில்லைகள் ஒரு பண்டமாகச் செயல்படுகின்றன. இதற்கு நேர்மாறாக, ERC-721 வில்லைகள் வெவ்வேறு பூனை கார்ட்டூன்கள் (opens in a new tab) அல்லது வெவ்வேறு ரியல் எஸ்டேட் சொத்துகளின் பத்திரங்கள் போன்ற ஒரே மாதிரியான ஆனால் முற்றிலும் ஒன்றல்லாத சொத்துகளுக்காக வடிவமைக்கப்பட்டுள்ளன.

இந்தக் கட்டுரையில் நாம் Ryuya Nakamura-வின் ERC-721 ஒப்பந்தத்தை (opens in a new tab) பகுப்பாய்வு செய்வோம். இந்த ஒப்பந்தம் Vyper (opens in a new tab)-இல் எழுதப்பட்டுள்ளது, இது Solidity-ஐ விட பாதுகாப்பற்ற குறியீட்டை எழுதுவதைக் கடினமாக்கும் வகையில் வடிவமைக்கப்பட்ட Python போன்ற ஒப்பந்த மொழியாகும்.

ஒப்பந்தம்

# @dev ERC-721 மாற்ற முடியாத வில்லை தரநிலையின் செயலாக்கம்.
# @author Ryuya Nakamura (@nrryuya)
# இதிலிருந்து மாற்றியமைக்கப்பட்டது: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy

Python-ஐப் போலவே Vyper-இலும் குறிப்புகள் ஒரு ஹாஷ் (#) குறியீட்டுடன் தொடங்கி வரியின் இறுதி வரை தொடரும். மனிதர்கள் படிக்கக்கூடிய ஆவணங்களை உருவாக்க NatSpec (opens in a new tab)-ஆல் @<keyword> உள்ளடங்கிய குறிப்புகள் பயன்படுத்தப்படுகின்றன.

from vyper.interfaces import ERC721

implements: ERC721

ERC-721 இடைமுகம் Vyper மொழியிலேயே கட்டமைக்கப்பட்டுள்ளது. குறியீட்டு வரையறையை நீங்கள் இங்கே காணலாம் (opens in a new tab). இடைமுக வரையறை Vyper-க்கு பதிலாக Python-இல் எழுதப்பட்டுள்ளது, ஏனெனில் இடைமுகங்கள் தொகுதிச்சங்கிலிக்குள் மட்டுமல்லாமல், Python-இல் எழுதப்பட்டிருக்கக்கூடிய வெளிப்புற கிளையண்டிலிருந்து தொகுதிச்சங்கிலிக்கு ஒரு பரிவர்த்தனையை அனுப்பும்போதும் பயன்படுத்தப்படுகின்றன.

முதல் வரி இடைமுகத்தை இறக்குமதி செய்கிறது, இரண்டாவது வரி அதை நாம் இங்கு செயல்படுத்துகிறோம் என்பதைக் குறிப்பிடுகிறது.

ERC721Receiver இடைமுகம்

# safeTransferFrom() மூலம் அழைக்கப்படும் ஒப்பந்தம் க்கான இடைமுகம்
interface ERC721Receiver:
    def onERC721Received(

ERC-721 இரண்டு வகையான பரிமாற்றங்களை ஆதரிக்கிறது:

transferFrom, இது அனுப்புநரை எந்தவொரு இலக்கு முகவரியையும் குறிப்பிட அனுமதிக்கிறது மற்றும் பரிமாற்றத்திற்கான பொறுப்பை அனுப்புநரிடமே அளிக்கிறது. இதன் பொருள் நீங்கள் செல்லுபடியாகாத முகவரிக்கு பரிமாற்றம் செய்யலாம், அவ்வாறு செய்தால் NFT நிரந்தரமாக இழக்கப்படும்.
safeTransferFrom, இது இலக்கு முகவரி ஒரு ஒப்பந்தமா என்பதைச் சரிபார்க்கிறது. அப்படியானால், ERC-721 ஒப்பந்தம் பெறும் ஒப்பந்தத்திடம் NFT-ஐப் பெற விரும்புகிறதா என்று கேட்கும்.

safeTransferFrom கோரிக்கைகளுக்குப் பதிலளிக்க, பெறும் ஒப்பந்தம் ERC721Receiver-ஐச் செயல்படுத்த வேண்டும்.

            _operator: address,
            _from: address,

_from முகவரி என்பது வில்லைகளின் தற்போதைய உரிமையாளர். _operator முகவரி என்பது பரிமாற்றத்தைக் கோரியவர் (அனுமதித்தொகைகள் காரணமாக இவை இரண்டும் ஒன்றாக இருக்க வேண்டியதில்லை).

            _tokenId: uint256,

ERC-721 வில்லை ID-கள் 256 பிட்கள் ஆகும். பொதுவாக அவை வில்லை எதைக் குறிக்கிறதோ அதன் விளக்கத்தை ஹாஷ் செய்வதன் மூலம் உருவாக்கப்படுகின்றன.

            _data: Bytes[1024]

கோரிக்கையானது 1024 பைட்டுகள் வரையிலான பயனர் தரவைக் கொண்டிருக்கலாம்.

        ) -> bytes32: view

ஒரு ஒப்பந்தம் தற்செயலாக ஒரு பரிமாற்றத்தை ஏற்கும் நிகழ்வுகளைத் தடுக்க, திரும்பப் பெறும் மதிப்பு ஒரு பூலியன் அல்ல, மாறாக ஒரு குறிப்பிட்ட மதிப்புடன் கூடிய 256 பிட்கள் ஆகும்.

இந்தச் செயல்பாடு ஒரு view ஆகும், அதாவது இது தொகுதிச்சங்கிலியின் நிலையைப் படிக்க முடியும், ஆனால் அதை மாற்ற முடியாது.

நிகழ்வுகள்

தொகுதிச்சங்கிலிக்கு வெளியே உள்ள பயனர்களுக்கும் சேவையகங்களுக்கும் நிகழ்வுகளைத் தெரிவிக்க நிகழ்வுகள் வெளியிடப்படுகின்றன. நிகழ்வுகளின் உள்ளடக்கம் தொகுதிச்சங்கிலியில் உள்ள ஒப்பந்தங்களுக்குக் கிடைக்காது என்பதை நினைவில் கொள்ளவும்.

# @dev எந்தவொரு NFT-இன் உரிமையும் எந்தவொரு பொறிமுறையாலும் மாறும்போது வெளியிடுகிறது. NFT-கள் பின்வருமாறு இருக்கும்போது இந்த நிகழ்வு வெளியிடுகிறது
#      உருவாக்கப்படும்போது (`from` == 0) மற்றும் அழிக்கப்படும்போது (`to` == 0). விதிவிலக்கு: ஒப்பந்தம் உருவாக்கத்தின் போது, எந்தவொரு
#      எண்ணிக்கையிலான NFT-கள் பரிமாற்றம் வெளியிடப்படாமல் உருவாக்கப்பட்டு ஒதுக்கப்படலாம். எந்தவொரு
#      பரிமாற்றம் நடைபெறும் நேரத்திலும், அந்த NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரி (ஏதேனும் இருந்தால்) ஏதுமில்லை என மீட்டமைக்கப்படும்.
# @param _from NFT-ஐ அனுப்புபவர் (முகவரி சுழி முகவரி ஆக இருந்தால் அது வில்லை உருவாக்கத்தைக் குறிக்கிறது).
# @param _to NFT-ஐ பெறுபவர் (முகவரி சுழி முகவரி ஆக இருந்தால் அது வில்லை அழிப்பைக் குறிக்கிறது).
# @param _tokenId பரிமாற்றம் செய்யப்பட்ட NFT.
event Transfer:
    sender: indexed(address)
    receiver: indexed(address)
    tokenId: indexed(uint256)

இது ERC-20 பரிமாற்ற நிகழ்வைப் போன்றது, ஆனால் நாம் ஒரு தொகைக்குப் பதிலாக tokenId-ஐத் தெரிவிக்கிறோம். சுழி முகவரி யாருக்கும் சொந்தமானது அல்ல, எனவே மரபுப்படி வில்லைகளின் உருவாக்கம் மற்றும் அழிப்பைப் புகாரளிக்க அதைப் பயன்படுத்துகிறோம்.

# @dev ஒரு NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரி மாற்றப்படும்போது அல்லது மீண்டும் உறுதிப்படுத்தப்படும்போது இது வெளியிடுகிறது. சுழி
#      முகவரி அங்கீகரிக்கப்பட்ட முகவரி ஏதுமில்லை என்பதைக் குறிக்கிறது. ஒரு பரிமாற்றம் நிகழ்வு வெளியிடும்போது, இதுவும்
#      அந்த NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரி (ஏதேனும் இருந்தால்) ஏதுமில்லை என மீட்டமைக்கப்படுவதைக் குறிக்கிறது.
# @param _owner NFT-இன் உரிமையாளர்.
# @param _approved நாம் அங்கீகரிக்கும் முகவரி.
# @param _tokenId நாம் அங்கீகரிக்கும் NFT.
event Approval:
    owner: indexed(address)
    approved: indexed(address)
    tokenId: indexed(uint256)

ERC-721 ஒப்புதல் என்பது ERC-20 அனுமதித்தொகையைப் போன்றது. ஒரு குறிப்பிட்ட முகவரி ஒரு குறிப்பிட்ட வில்லையைப் பரிமாற்றம் செய்ய அனுமதிக்கப்படுகிறது. ஒப்பந்தங்கள் ஒரு வில்லையை ஏற்கும் போது பதிலளிக்க இது ஒரு வழிமுறையை வழங்குகிறது. ஒப்பந்தங்களால் நிகழ்வுகளைக் கேட்க முடியாது, எனவே நீங்கள் வில்லையை அவற்றுக்கு மாற்றினால், அது பற்றி அவற்றுக்குத் "தெரியாது". இந்த வழியில் உரிமையாளர் முதலில் ஒரு ஒப்புதலைச் சமர்ப்பித்து, பின்னர் ஒப்பந்தத்திற்கு ஒரு கோரிக்கையை அனுப்புகிறார்: "வில்லை X-ஐப் பரிமாற்றம் செய்ய நான் உங்களுக்கு ஒப்புதல் அளித்துள்ளேன், தயவுசெய்து ... செய்யுங்கள்".

இது ERC-721 தரநிலையை ERC-20 தரநிலைக்கு ஒத்ததாக மாற்றுவதற்கான ஒரு வடிவமைப்புத் தேர்வாகும். ERC-721 வில்லைகள் பூஞ்சையற்றவை என்பதால், ஒரு ஒப்பந்தம் வில்லையின் உரிமையைப் பார்ப்பதன் மூலம் ஒரு குறிப்பிட்ட வில்லையைப் பெற்றுள்ளது என்பதையும் அடையாளம் காண முடியும்.

# @dev ஒரு உரிமையாளருக்கு ஒரு ஆபரேட்டர் செயல்படுத்தப்படும்போது அல்லது முடக்கப்படும்போது இது வெளியிடுகிறது. ஆபரேட்டர்
#      உரிமையாளரின் அனைத்து NFT-களையும் நிர்வகிக்க முடியும்.
# @param _owner NFT-இன் உரிமையாளர்.
# @param _operator நாம் ஆபரேட்டர் உரிமைகளை அமைக்கும் முகவரி.
# @param _approved ஆபரேட்டர் உரிமைகளின் நிலை (ஆபரேட்டர் உரிமைகள் வழங்கப்பட்டால் true மற்றும்
# திரும்பப் பெறப்பட்டால் false).
event ApprovalForAll:
    owner: indexed(address)
    operator: indexed(address)
    approved: bool

சில நேரங்களில் ஒரு கணக்கின் குறிப்பிட்ட வகையிலான அனைத்து வில்லைகளையும் (ஒரு குறிப்பிட்ட ஒப்பந்தத்தால் நிர்வகிக்கப்படுபவை) நிர்வகிக்கக்கூடிய ஒரு ஆபரேட்டரை (operator) வைத்திருப்பது பயனுள்ளதாக இருக்கும், இது பவர் ஆஃப் அட்டர்னியைப் போன்றது. எடுத்துக்காட்டாக, நான் ஆறு மாதங்களாகத் தொடர்புகொள்ளவில்லையா என்பதைச் சரிபார்த்து, அவ்வாறு இருந்தால் எனது சொத்துகளை எனது வாரிசுகளுக்குப் பகிர்ந்தளிக்கும் ஒரு ஒப்பந்தத்திற்கு அத்தகைய அதிகாரத்தை வழங்க நான் விரும்பலாம் (அவர்களில் ஒருவர் அதைக் கேட்டால் மட்டுமே, ஒரு பரிவர்த்தனையால் அழைக்கப்படாமல் ஒப்பந்தங்களால் எதையும் செய்ய முடியாது). ERC-20-இல் நாம் ஒரு பரம்பரை ஒப்பந்தத்திற்கு அதிக அனுமதித்தொகையை வழங்க முடியும், ஆனால் ERC-721-க்கு அது வேலை செய்யாது, ஏனெனில் வில்லைகள் பூஞ்சையற்றவை. இது அதற்குச் சமமானதாகும்.

approved மதிப்பானது நிகழ்வு ஒரு ஒப்புதலுக்கானதா அல்லது ஒப்புதலைத் திரும்பப் பெறுவதற்கானதா என்பதை நமக்குக் கூறுகிறது.

நிலை மாறிகள்

இந்த மாறிகள் வில்லைகளின் தற்போதைய நிலையைக் கொண்டுள்ளன: எவை கிடைக்கின்றன மற்றும் அவற்றை யார் வைத்திருக்கிறார்கள். இவற்றில் பெரும்பாலானவை HashMap ஆப்ஜெக்ட்கள், இரண்டு வகைகளுக்கு இடையே இருக்கும் ஒருவழி மேப்பிங்குகள் (opens in a new tab) ஆகும்.

# @dev NFT ID-யிலிருந்து அதைச் சொந்தமாகக் கொண்ட முகவரி க்கான மேப்பிங்.
idToOwner: HashMap[uint256, address]

# @dev NFT ID-யிலிருந்து அங்கீகரிக்கப்பட்ட முகவரி க்கான மேப்பிங்.
idToApprovals: HashMap[uint256, address]

எத்திரியத்தில் பயனர் மற்றும் ஒப்பந்த அடையாளங்கள் 160-பிட் முகவரிகளால் குறிக்கப்படுகின்றன. இந்த இரண்டு மாறிகளும் வில்லை ID-களிலிருந்து அவற்றின் உரிமையாளர்களுக்கும் அவற்றைப் பரிமாற்றம் செய்ய அங்கீகரிக்கப்பட்டவர்களுக்கும் (ஒவ்வொன்றுக்கும் அதிகபட்சம் ஒன்று) மேப் செய்கின்றன. எத்திரியத்தில், துவக்கப்படாத தரவு எப்போதும் சுழியாகவே இருக்கும், எனவே உரிமையாளர் அல்லது அங்கீகரிக்கப்பட்ட பரிமாற்றுபவர் இல்லை என்றால் அந்த வில்லைக்கான மதிப்பு சுழியாகும்.

# @dev உரிமையாளர் முகவரி யிலிருந்து அவரது வில்லை களின் எண்ணிக்கைக்கான மேப்பிங்.
ownerToNFTokenCount: HashMap[address, uint256]

இந்த மாறி ஒவ்வொரு உரிமையாளருக்குமான வில்லைகளின் எண்ணிக்கையைக் கொண்டுள்ளது. உரிமையாளர்களிடமிருந்து வில்லைகளுக்கு எந்த மேப்பிங்கும் இல்லை, எனவே ஒரு குறிப்பிட்ட உரிமையாளர் வைத்திருக்கும் வில்லைகளை அடையாளம் காண ஒரே வழி, தொகுதிச்சங்கிலியின் நிகழ்வு வரலாற்றைத் திரும்பிப் பார்த்து பொருத்தமான Transfer நிகழ்வுகளைக் காண்பதுதான். நம்மிடம் அனைத்து NFT-களும் எப்போது உள்ளன என்பதையும், மேலும் பின்னோக்கிப் பார்க்கத் தேவையில்லை என்பதையும் அறிய இந்த மாறியைப் பயன்படுத்தலாம்.

இந்த அல்காரிதம் பயனர் இடைமுகங்கள் மற்றும் வெளிப்புற சேவையகங்களுக்கு மட்டுமே வேலை செய்யும் என்பதை நினைவில் கொள்ளவும். தொகுதிச்சங்கிலியிலேயே இயங்கும் குறியீட்டால் கடந்த கால நிகழ்வுகளைப் படிக்க முடியாது.

# @dev உரிமையாளர் முகவரி யிலிருந்து ஆபரேட்டர் முகவரி களின் மேப்பிங்கிற்கான மேப்பிங்.
ownerToOperators: HashMap[address, HashMap[address, bool]]

ஒரு கணக்கில் ஒன்றுக்கு மேற்பட்ட ஆபரேட்டர்கள் இருக்கலாம். அவற்றைக் கண்காணிக்க ஒரு எளிய HashMap போதுமானதல்ல, ஏனெனில் ஒவ்வொரு திறவுகோலும் ஒரு ஒற்றை மதிப்புக்கு வழிவகுக்கிறது. அதற்குப் பதிலாக, நீங்கள் HashMap[address, bool]-ஐ மதிப்பாகப் பயன்படுத்தலாம். இயல்பாக ஒவ்வொரு முகவரிக்கான மதிப்பும் False ஆகும், அதாவது அது ஒரு ஆபரேட்டர் அல்ல. தேவைக்கேற்ப நீங்கள் மதிப்புகளை True என அமைக்கலாம்.

# @dev ஒரு வில்லை ஐ அச்சிடு செய்யக்கூடிய அச்சிடுபவரின் முகவரி
minter: address

புதிய வில்லைகள் எப்படியாவது உருவாக்கப்பட வேண்டும். இந்த ஒப்பந்தத்தில் அவ்வாறு செய்ய அனுமதிக்கப்பட்ட ஒரே ஒரு நிறுவனம் உள்ளது, அது minter ஆகும். எடுத்துக்காட்டாக, ஒரு விளையாட்டுக்கு இது போதுமானதாக இருக்கலாம். பிற நோக்கங்களுக்காக, மிகவும் சிக்கலான வணிக தர்க்கத்தை உருவாக்குவது அவசியமாக இருக்கலாம்.

# @dev இடைமுக ஐடி ஆதரிக்கப்படுகிறதா இல்லையா என்பது பற்றிய பூலியனுக்கான மேப்பிங்
supportedInterfaces: HashMap[bytes32, bool]

# @dev ERC-165 இன் ERC-165 இடைமுக ஐடி
ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7

# @dev ERC-721 இன் ERC-165 இடைமுக ஐடி
ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd

பயன்பாடுகள் அதனுடன் எவ்வாறு தொடர்பு கொள்ளலாம், எந்த ERC-களுக்கு அது இணங்குகிறது என்பதை ஒரு ஒப்பந்தம் வெளிப்படுத்துவதற்கான ஒரு வழிமுறையை ERC-165 (opens in a new tab) குறிப்பிடுகிறது. இந்த நிலையில், ஒப்பந்தம் ERC-165 மற்றும் ERC-721 ஆகியவற்றுக்கு இணங்குகிறது.

செயல்பாடுகள்

இவைதான் உண்மையில் ERC-721-ஐச் செயல்படுத்தும் செயல்பாடுகள் ஆகும்.

ஆக்கி

@external
def __init__():

Python-ஐப் போலவே Vyper-இலும், ஆக்கிச் செயல்பாடு __init__ என்று அழைக்கப்படுகிறது.

    """
    @dev ஒப்பந்தம் ஆக்கி.
    """

Python மற்றும் Vyper-இல், பல வரி சரத்தைக் குறிப்பிடுவதன் மூலமும் (இது """ உடன் தொடங்கி முடிவடையும்), அதை எந்த வகையிலும் பயன்படுத்தாமலும் நீங்கள் ஒரு குறிப்பை உருவாக்கலாம். இந்தக் குறிப்புகளில் NatSpec (opens in a new tab)-உம் அடங்கலாம்.

    self.supportedInterfaces[ERC165_INTERFACE_ID] = True
    self.supportedInterfaces[ERC721_INTERFACE_ID] = True
    self.minter = msg.sender

நிலை மாறிகளை அணுக நீங்கள் self.<variable name>-ஐப் பயன்படுத்துகிறீர்கள் (மீண்டும், Python-இல் உள்ளதைப் போலவே).

காட்சிச் செயல்பாடுகள்

இவை தொகுதிச்சங்கிலியின் நிலையை மாற்றாத செயல்பாடுகள் ஆகும், எனவே அவை வெளிப்புறமாக அழைக்கப்பட்டால் இலவசமாக இயக்கப்படலாம். காட்சிச் செயல்பாடுகள் ஒரு ஒப்பந்தத்தால் அழைக்கப்பட்டால், அவை இன்னும் ஒவ்வொரு கணுவிலும் இயக்கப்பட வேண்டும், எனவே எரிவாயு செலவாகும்.

@view
@external

ஒரு செயல்பாட்டு வரையறைக்கு முன்னதாக அட் குறியீட்டுடன் (@) தொடங்கும் இந்த முக்கிய வார்த்தைகள் அலங்காரங்கள் (decorations) என்று அழைக்கப்படுகின்றன. ஒரு செயல்பாட்டை எந்தச் சூழ்நிலைகளில் அழைக்கலாம் என்பதை அவை குறிப்பிடுகின்றன.

@view இந்தச் செயல்பாடு ஒரு காட்சி என்பதைக் குறிப்பிடுகிறது.
@external இந்தக் குறிப்பிட்ட செயல்பாட்டைப் பரிவர்த்தனைகள் மற்றும் பிற ஒப்பந்தங்களால் அழைக்க முடியும் என்பதைக் குறிப்பிடுகிறது.

def supportsInterface(_interfaceID: bytes32) -> bool:

Python-க்கு நேர்மாறாக, Vyper ஒரு நிலையான தட்டச்சு செய்யப்பட்ட மொழி (opens in a new tab) (static typed language) ஆகும். தரவு வகையை (opens in a new tab) அடையாளம் காணாமல் நீங்கள் ஒரு மாறியையோ அல்லது செயல்பாட்டு அளவுருவையோ அறிவிக்க முடியாது. இந்த நிலையில் உள்ளீட்டு அளவுரு bytes32 ஆகும், இது ஒரு 256-பிட் மதிப்பு (256 பிட்கள் என்பது எத்திரியம் மெய்நிகர் இயந்திரத்தின் இயல்பான சொல் அளவு). வெளியீடு ஒரு பூலியன் மதிப்பு. மரபுப்படி, செயல்பாட்டு அளவுருக்களின் பெயர்கள் அடிக்கோட்டுடன் (_) தொடங்குகின்றன.

    """
    @dev இடைமுக அடையாளம் ERC-165 இல் குறிப்பிடப்பட்டுள்ளது.
    @param _interfaceID இடைமுகத்தின் ஐடி
    """
    return self.supportedInterfaces[_interfaceID]

ஆக்கியில் (__init__) அமைக்கப்பட்ட self.supportedInterfaces HashMap-இலிருந்து மதிப்பைத் திருப்பி அனுப்பவும்.

### பார்வை செயல்பாடுகள் ###

பயனர்களுக்கும் பிற ஒப்பந்தங்களுக்கும் வில்லைகள் பற்றிய தகவல்களைக் கிடைக்கச் செய்யும் காட்சிச் செயல்பாடுகள் இவை.

@view
@external
def balanceOf(_owner: address) -> uint256:
    """
    @dev `_owner` க்குச் சொந்தமான NFT-களின் எண்ணிக்கையை வழங்குகிறது.
         `_owner` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும். சுழி முகவரி க்கு ஒதுக்கப்பட்ட NFT-கள் செல்லுபடியற்றவையாகக் கருதப்படும்.
    @param _owner இருப்பை வினவ வேண்டிய முகவரி.
    """
    assert _owner != ZERO_ADDRESS

இந்த வரி _owner சுழியாக இல்லை என்பதை உறுதிப்படுத்துகிறது (opens in a new tab). அவ்வாறு இருந்தால், ஒரு பிழை ஏற்பட்டு செயல்பாடு மீளமைக்கப்படும்.

    return self.ownerToNFTokenCount[_owner]

@view
@external
def ownerOf(_tokenId: uint256) -> address:
    """
    @dev NFT-இன் உரிமையாளரின் முகவரி ஐ வழங்குகிறது.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்.
    @param _tokenId ஒரு NFT-க்கான அடையாளங்காட்டி.
    """
    owner: address = self.idToOwner[_tokenId]
    # `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்
    assert owner != ZERO_ADDRESS
    return owner

எத்திரியம் மெய்நிகர் இயந்திரத்தில் (EVM) மதிப்பு சேமிக்கப்படாத எந்தவொரு சேமிப்பகமும் சுழியாகும். _tokenId-இல் வில்லை இல்லை என்றால், self.idToOwner[_tokenId]-இன் மதிப்பு சுழியாகும். அந்த நிலையில் செயல்பாடு மீளமைக்கப்படும்.

@view
@external
def getApproved(_tokenId: uint256) -> address:
    """
    @dev ஒரு ஒற்றை NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரி ஐப் பெறவும்.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்.
    @param _tokenId அங்கீகாரத்தை வினவ வேண்டிய NFT-இன் ஐடி.
    """
    # `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்
    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
    return self.idToApprovals[_tokenId]

getApproved சுழியைத் திருப்பி அனுப்ப முடியும் என்பதை நினைவில் கொள்ளவும். வில்லை செல்லுபடியாகும் என்றால் அது self.idToApprovals[_tokenId]-ஐத் திருப்பி அனுப்பும். ஒப்புதல் அளிப்பவர் இல்லை என்றால் அந்த மதிப்பு சுழியாகும்.

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

இந்த ஒப்பந்தத்தில் உள்ள _owner-இன் அனைத்து வில்லைகளையும் நிர்வகிக்க _operator அனுமதிக்கப்படுகிறதா என்பதை இந்தச் செயல்பாடு சரிபார்க்கிறது. பல ஆபரேட்டர்கள் இருக்க முடியும் என்பதால், இது இரண்டு நிலை HashMap ஆகும்.

பரிமாற்ற உதவிச் செயல்பாடுகள்

இந்தச் செயல்பாடுகள் வில்லைகளைப் பரிமாற்றம் செய்யும் அல்லது நிர்வகிக்கும் செயல்பாடுகளைச் செயல்படுத்துகின்றன.


### பரிமாற்றம் செயல்பாட்டு உதவியாளர்கள் ###

@view
@internal

இந்த அலங்காரம், @internal, செயல்பாடு அதே ஒப்பந்தத்திற்குள் உள்ள பிற செயல்பாடுகளிலிருந்து மட்டுமே அணுகக்கூடியது என்பதைக் குறிக்கிறது. மரபுப்படி, இந்தச் செயல்பாட்டுப் பெயர்களும் அடிக்கோட்டுடன் (_) தொடங்குகின்றன.

def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
    """
    @dev கொடுக்கப்பட்ட செலவழிப்பவர் கொடுக்கப்பட்ட வில்லை ஐடியை பரிமாற்றம் செய்ய முடியுமா என்பதை வழங்குகிறது
    @param spender வினவ வேண்டிய செலவழிப்பவரின் முகவரி
    @param tokenId பரிமாற்றம் செய்யப்பட வேண்டிய வில்லை இன் uint256 ஐடி
    @return bool msg.sender கொடுக்கப்பட்ட வில்லை ஐடிக்கு அங்கீகரிக்கப்பட்டுள்ளாரா,
        உரிமையாளரின் ஆபரேட்டரா, அல்லது வில்லை இன் உரிமையாளரா என்பது
    """
    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 கொடுக்கப்பட்ட முகவரி க்கு ஒரு NFT-ஐச் சேர்க்கவும்
         `_tokenId` யாருக்காவது சொந்தமாக இருந்தால் பிழையை எறியும்.
    """
    # `_tokenId` யாருக்காவது சொந்தமாக இருந்தால் பிழையை எறியும்
    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
    # உரிமையாளரை மாற்றவும்
    self.idToOwner[_tokenId] = _to
    # எண்ணிக்கை கண்காணிப்பை மாற்றவும்
    self.ownerToNFTokenCount[_to] += 1


@internal
def _removeTokenFrom(_from: address, _tokenId: uint256):
    """
    @dev கொடுக்கப்பட்ட முகவரி யிலிருந்து ஒரு NFT-ஐ அகற்றவும்
         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்.
    """
    # `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்
    assert self.idToOwner[_tokenId] == _from
    # உரிமையாளரை மாற்றவும்
    self.idToOwner[_tokenId] = ZERO_ADDRESS
    # எண்ணிக்கை கண்காணிப்பை மாற்றவும்
    self.ownerToNFTokenCount[_from] -= 1

ஒரு பரிமாற்றத்தில் சிக்கல் ஏற்படும் போது நாம் அழைப்பை மீளமைக்கிறோம்.

@internal
def _clearApproval(_owner: address, _tokenId: uint256):
    """
    @dev கொடுக்கப்பட்ட முகவரி இன் அங்கீகாரத்தை அழிக்கவும்
         `_owner` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்.
    """
    # `_owner` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்
    assert self.idToOwner[_tokenId] == _owner
    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
        # அங்கீகாரங்களை மீட்டமைக்கவும்
        self.idToApprovals[_tokenId] = ZERO_ADDRESS

தேவைப்பட்டால் மட்டுமே மதிப்பை மாற்றவும். நிலை மாறிகள் சேமிப்பகத்தில் வாழ்கின்றன. சேமிப்பகத்தில் எழுதுவது EVM (எத்திரியம் மெய்நிகர் இயந்திரம்) செய்யும் மிகவும் விலையுயர்ந்த செயல்பாடுகளில் ஒன்றாகும் (எரிவாயு அடிப்படையில்). எனவே, அதைக் குறைப்பது ஒரு நல்ல யோசனையாகும், இருக்கும் மதிப்பை எழுதுவது கூட அதிகச் செலவைக் கொண்டுள்ளது.

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

வில்லைகளைப் பரிமாற்றம் செய்ய இரண்டு வழிகள் (வழக்கமான மற்றும் பாதுகாப்பான) இருப்பதால் இந்த உள் செயல்பாடு நம்மிடம் உள்ளது, ஆனால் தணிக்கையை எளிதாக்க குறியீட்டில் அதைச் செய்யும் ஒரே ஒரு இடம் மட்டுமே நமக்குத் தேவை.

    # தேவைகளைச் சரிபார்க்கவும்
    assert self._isApprovedOrOwner(_sender, _tokenId)
    # `_to` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும்
    assert _to != ZERO_ADDRESS
    # அங்கீகாரத்தை அழிக்கவும். `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்
    self._clearApproval(_from, _tokenId)
    # NFT-ஐ அகற்றவும். `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்
    self._removeTokenFrom(_from, _tokenId)
    # NFT-ஐச் சேர்க்கவும்
    self._addTokenTo(_to, _tokenId)
    # பரிமாற்றம் ஐப் பதிவு செய்யவும்
    log Transfer(_from, _to, _tokenId)

Vyper-இல் ஒரு நிகழ்வை வெளியிட நீங்கள் log அறிக்கையைப் பயன்படுத்துகிறீர்கள் (மேலும் விவரங்களுக்கு இங்கே பார்க்கவும் (opens in a new tab)).

பரிமாற்றச் செயல்பாடுகள்


### பரிமாற்றம் செயல்பாடுகள் ###

@external
def transferFrom(_from: address, _to: address, _tokenId: uint256):
    """
    @dev `msg.sender` தற்போதைய உரிமையாளராக, அங்கீகரிக்கப்பட்ட ஆபரேட்டராக அல்லது இந்த NFT-க்கான அங்கீகரிக்கப்பட்ட
         முகவரி ஆக இல்லாவிட்டால் பிழையை எறியும்.
         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்.
         `_to` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும்.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்.
    @notice `_to` NFT-களைப் பெறும் திறன் கொண்டதா என்பதை உறுதிப்படுத்துவது அழைப்பாளரின் பொறுப்பாகும், இல்லையெனில்
            அவை நிரந்தரமாக இழக்கப்படலாம்.
    @param _from NFT-இன் தற்போதைய உரிமையாளர்.
    @param _to புதிய உரிமையாளர்.
    @param _tokenId பரிமாற்றம் செய்ய வேண்டிய NFT.
    """
    self._transferFrom(_from, _to, _tokenId, msg.sender)

இந்தச் செயல்பாடு உங்களை ஒரு தன்னிச்சையான முகவரிக்குப் பரிமாற்றம் செய்ய அனுமதிக்கிறது. முகவரி ஒரு பயனராகவோ அல்லது வில்லைகளை எவ்வாறு பரிமாற்றம் செய்வது என்று தெரிந்த ஒரு ஒப்பந்தமாகவோ இல்லாவிட்டால், நீங்கள் பரிமாற்றம் செய்யும் எந்தவொரு வில்லையும் அந்த முகவரியில் சிக்கிக்கொண்டு பயனற்றதாகிவிடும்.

@external
def safeTransferFrom(
        _from: address,
        _to: address,
        _tokenId: uint256,
        _data: Bytes[1024]=b""
    ):
    """
    @dev ஒரு NFT-இன் உரிமையை ஒரு முகவரி யிலிருந்து மற்றொரு முகவரி க்கு பரிமாற்றம் செய்கிறது.
         `msg.sender` தற்போதைய உரிமையாளராக, அங்கீகரிக்கப்பட்ட ஆபரேட்டராக அல்லது இந்த NFT-க்கான
         அங்கீகரிக்கப்பட்ட முகவரி ஆக இல்லாவிட்டால் பிழையை எறியும்.
         `_from` தற்போதைய உரிமையாளராக இல்லாவிட்டால் பிழையை எறியும்.
         `_to` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும்.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்.
         `_to` ஒரு ஸ்மார்ட் ஒப்பந்தம் ஆக இருந்தால், அது `_to` இல் `onERC721Received` ஐ அழைக்கிறது மற்றும்
         திரும்பப் பெறும் மதிப்பு `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` ஆக இல்லாவிட்டால் பிழையை எறியும்.
         குறிப்பு: bytes4 என்பது பேடிங் உடன் bytes32 ஆல் குறிக்கப்படுகிறது
    @param _from NFT-இன் தற்போதைய உரிமையாளர்.
    @param _to புதிய உரிமையாளர்.
    @param _tokenId பரிமாற்றம் செய்ய வேண்டிய NFT.
    @param _data `_to` க்கான அழைப்பில் அனுப்பப்பட்ட, குறிப்பிட்ட வடிவம் இல்லாத கூடுதல் தரவு.
    """
    self._transferFrom(_from, _to, _tokenId, msg.sender)

முதலில் பரிமாற்றத்தைச் செய்வது சரியானது, ஏனெனில் ஏதேனும் சிக்கல் இருந்தால் எப்படியும் நாம் மீளமைக்கப் போகிறோம், எனவே அழைப்பில் செய்யப்பட்ட அனைத்தும் ரத்து செய்யப்படும்.

    if _to.is_contract: # `_to` ஒரு ஒப்பந்தம் முகவரி ஆ என்பதைச் சரிபார்க்கவும்

முதலில் முகவரி ஒரு ஒப்பந்தமா என்பதைச் சரிபார்க்கவும் (அதில் குறியீடு இருந்தால்). இல்லையென்றால், அது ஒரு பயனர் முகவரி என்றும் பயனர் வில்லையைப் பயன்படுத்தவோ அல்லது பரிமாற்றம் செய்யவோ முடியும் என்றும் கருதுங்கள். ஆனால் அது உங்களை ஒரு தவறான பாதுகாப்பு உணர்வுக்குள் தள்ள அனுமதிக்காதீர்கள். யாருக்கும் தனிப்பட்ட திறவுகோல் தெரியாத ஒரு முகவரிக்கு நீங்கள் வில்லைகளைப் பரிமாற்றம் செய்தால், safeTransferFrom உடன் கூட நீங்கள் வில்லைகளை இழக்க நேரிடலாம்.

        returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)

இலக்கு ஒப்பந்தம் ERC-721 வில்லைகளைப் பெற முடியுமா என்பதைப் பார்க்க அதை அழைக்கவும்.

        # பரிமாற்றம் இலக்கு 'onERC721Received' ஐச் செயல்படுத்தாத ஒரு ஒப்பந்தம் ஆக இருந்தால் பிழையை எறியும்
        assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)

இலக்கு ஒரு ஒப்பந்தமாக இருந்து, ஆனால் அது ERC-721 வில்லைகளை ஏற்கவில்லை என்றால் (அல்லது இந்தக் குறிப்பிட்ட பரிமாற்றத்தை ஏற்க வேண்டாம் என்று முடிவு செய்தால்), மீளமைக்கவும்.

@external
def approve(_approved: address, _tokenId: uint256):
    """
    @dev ஒரு NFT-க்கான அங்கீகரிக்கப்பட்ட முகவரி ஐ அமைக்கவும் அல்லது மீண்டும் உறுதிப்படுத்தவும். சுழி முகவரி அங்கீகரிக்கப்பட்ட முகவரி ஏதுமில்லை என்பதைக் குறிக்கிறது.
         `msg.sender` தற்போதைய NFT உரிமையாளராக அல்லது தற்போதைய உரிமையாளரின் அங்கீகரிக்கப்பட்ட ஆபரேட்டராக இல்லாவிட்டால் பிழையை எறியும்.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும். (குறிப்பு: இது EIP இல் எழுதப்படவில்லை)
         `_approved` தற்போதைய உரிமையாளராக இருந்தால் பிழையை எறியும். (குறிப்பு: இது EIP இல் எழுதப்படவில்லை)
    @param _approved கொடுக்கப்பட்ட NFT ஐடிக்கு அங்கீகரிக்கப்பட வேண்டிய முகவரி.
    @param _tokenId அங்கீகரிக்கப்பட வேண்டிய வில்லை இன் ஐடி.
    """
    owner: address = self.idToOwner[_tokenId]
    # `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்
    assert owner != ZERO_ADDRESS
    # `_approved` தற்போதைய உரிமையாளராக இருந்தால் பிழையை எறியும்
    assert _approved != owner

மரபுப்படி நீங்கள் ஒரு ஒப்புதல் அளிப்பவரைக் கொண்டிருக்க விரும்பவில்லை என்றால், உங்களை அல்ல, சுழி முகவரியை நியமிக்கிறீர்கள்.

    # தேவைகளைச் சரிபார்க்கவும்
    senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
    senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
    assert (senderIsOwner or senderIsApprovedForAll)

ஒரு ஒப்புதலை அமைக்க நீங்கள் உரிமையாளராகவோ அல்லது உரிமையாளரால் அங்கீகரிக்கப்பட்ட ஆபரேட்டராகவோ இருக்கலாம்.

    # அங்கீகாரத்தை அமைக்கவும்
    self.idToApprovals[_tokenId] = _approved
    log Approval(owner, _approved, _tokenId)


@external
def setApprovalForAll(_operator: address, _approved: bool):
    """
    @dev `msg.sender` இன் அனைத்து சொத்துகளையும் நிர்வகிக்க மூன்றாம் தரப்பினருக்கான ("ஆபரேட்டர்") அங்கீகாரத்தை செயல்படுத்துகிறது அல்லது முடக்குகிறது.
         இது ApprovalForAll நிகழ்வையும் வெளியிடுகிறது.
         `_operator` `msg.sender` ஆக இருந்தால் பிழையை எறியும். (குறிப்பு: இது EIP இல் எழுதப்படவில்லை)
    @notice அந்த நேரத்தில் அனுப்புநருக்கு எந்த வில்லை களும் சொந்தமாக இல்லாவிட்டாலும் இது வேலை செய்யும்.
    @param _operator அங்கீகரிக்கப்பட்ட ஆபரேட்டர்களின் தொகுப்பில் சேர்க்க வேண்டிய முகவரி.
    @param _approved ஆபரேட்டர்கள் அங்கீகரிக்கப்பட்டால் True, அங்கீகாரத்தை திரும்பப் பெற False.
    """
    # `_operator` `msg.sender` ஆக இருந்தால் பிழையை எறியும்
    assert _operator != msg.sender
    self.ownerToOperators[msg.sender][_operator] = _approved
    log ApprovalForAll(msg.sender, _operator, _approved)

புதிய வில்லைகளை அச்சிடுதல் மற்றும் ஏற்கனவே உள்ளவற்றை அழித்தல்

ஒப்பந்தத்தை உருவாக்கிய கணக்கு minter ஆகும், இது புதிய NFT-களை அச்சிட அங்கீகரிக்கப்பட்ட சூப்பர் பயனராகும். இருப்பினும், ஏற்கனவே உள்ள வில்லைகளை எரிக்க அது கூட அனுமதிக்கப்படவில்லை. உரிமையாளர் அல்லது உரிமையாளரால் அங்கீகரிக்கப்பட்ட ஒரு நிறுவனத்தால் மட்டுமே அதைச் செய்ய முடியும்.

### அச்சிடு & எரி செயல்பாடுகள் ###

@external
def mint(_to: address, _tokenId: uint256) -> bool:

இந்தச் செயல்பாடு எப்போதும் True-ஐத் திருப்பி அனுப்புகிறது, ஏனெனில் செயல்பாடு தோல்வியுற்றால் அது மீளமைக்கப்படும்.

    """
    @dev வில்லை களை அச்சிடு செய்வதற்கான செயல்பாடு
         `msg.sender` அச்சிடுபவராக இல்லாவிட்டால் பிழையை எறியும்.
         `_to` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும்.
         `_tokenId` யாருக்காவது சொந்தமாக இருந்தால் பிழையை எறியும்.
    @param _to அச்சிடு செய்யப்பட்ட வில்லை களைப் பெறும் முகவரி.
    @param _tokenId அச்சிடு செய்ய வேண்டிய வில்லை ஐடி.
    @return செயல்பாடு வெற்றிகரமாக இருந்ததா என்பதைக் குறிக்கும் பூலியன்.
    """
    # `msg.sender` அச்சிடுபவராக இல்லாவிட்டால் பிழையை எறியும்
    assert msg.sender == self.minter

அச்சிடுபவர் (ERC-721 ஒப்பந்தத்தை உருவாக்கிய கணக்கு) மட்டுமே புதிய வில்லைகளை அச்சிட முடியும். எதிர்காலத்தில் அச்சிடுபவரின் அடையாளத்தை மாற்ற விரும்பினால் இது ஒரு சிக்கலாக இருக்கலாம். ஒரு தயாரிப்பு ஒப்பந்தத்தில், அச்சிடுபவர் தனது அச்சிடும் சலுகைகளை வேறொருவருக்குப் பரிமாற்றம் செய்ய அனுமதிக்கும் ஒரு செயல்பாட்டை நீங்கள் விரும்பலாம்.

    # `_to` சுழி முகவரி ஆக இருந்தால் பிழையை எறியும்
    assert _to != ZERO_ADDRESS
    # NFT-ஐச் சேர்க்கவும். `_tokenId` யாருக்காவது சொந்தமாக இருந்தால் பிழையை எறியும்
    self._addTokenTo(_to, _tokenId)
    log Transfer(ZERO_ADDRESS, _to, _tokenId)
    return True

மரபுப்படி, புதிய வில்லைகளை அச்சிடுவது சுழி முகவரியிலிருந்து ஒரு பரிமாற்றமாகக் கணக்கிடப்படுகிறது.


@external
def burn(_tokenId: uint256):
    """
    @dev ஒரு குறிப்பிட்ட ERC-721 வில்லை ஐ எரி செய்கிறது.
         `msg.sender` தற்போதைய உரிமையாளராக, அங்கீகரிக்கப்பட்ட ஆபரேட்டராக அல்லது இந்த NFT-க்கான அங்கீகரிக்கப்பட்ட
         முகவரி ஆக இல்லாவிட்டால் பிழையை எறியும்.
         `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்.
    @param _tokenId எரி செய்யப்பட வேண்டிய ERC-721 வில்லை இன் uint256 ஐடி.
    """
    # தேவைகளைச் சரிபார்க்கவும்
    assert self._isApprovedOrOwner(msg.sender, _tokenId)
    owner: address = self.idToOwner[_tokenId]
    # `_tokenId` செல்லுபடியாகும் NFT ஆக இல்லாவிட்டால் பிழையை எறியும்
    assert owner != ZERO_ADDRESS
    self._clearApproval(owner, _tokenId)
    self._removeTokenFrom(owner, _tokenId)
    log Transfer(owner, ZERO_ADDRESS, _tokenId)

ஒரு வில்லையைப் பரிமாற்றம் செய்ய அனுமதிக்கப்பட்ட எவரும் அதை எரிக்கவும் அனுமதிக்கப்படுவார்கள். எரிப்பது சுழி முகவரிக்குப் பரிமாற்றம் செய்வதற்குச் சமமானதாகத் தோன்றினாலும், சுழி முகவரி உண்மையில் வில்லையைப் பெறுவதில்லை. இது வில்லைக்காகப் பயன்படுத்தப்பட்ட அனைத்துச் சேமிப்பகத்தையும் விடுவிக்க அனுமதிக்கிறது, இது பரிவர்த்தனையின் எரிவாயு செலவைக் குறைக்கலாம்.

இந்த ஒப்பந்தத்தைப் பயன்படுத்துதல்

Solidity-க்கு நேர்மாறாக, Vyper-இல் மரபுரிமை (inheritance) இல்லை. இது குறியீட்டைத் தெளிவாக்குவதற்கும், எனவே பாதுகாப்பதை எளிதாக்குவதற்கும் செய்யப்பட்ட ஒரு வேண்டுமென்றே வடிவமைப்புத் தேர்வாகும். எனவே உங்கள் சொந்த Vyper ERC-721 ஒப்பந்தத்தை உருவாக்க, நீங்கள் இந்த ஒப்பந்தத்தை (opens in a new tab) எடுத்து, நீங்கள் விரும்பும் வணிக தர்க்கத்தைச் செயல்படுத்த அதை மாற்றியமைக்கிறீர்கள்.

முடிவுரை

மதிப்பாய்வுக்காக, இந்த ஒப்பந்தத்தில் உள்ள சில மிக முக்கியமான கருத்துகள் இங்கே:

பாதுகாப்பான பரிமாற்றத்துடன் ERC-721 வில்லைகளைப் பெற, ஒப்பந்தங்கள் ERC721Receiver இடைமுகத்தைச் செயல்படுத்த வேண்டும்.
நீங்கள் பாதுகாப்பான பரிமாற்றத்தைப் பயன்படுத்தினாலும், தனிப்பட்ட திறவுகோல் தெரியாத முகவரிக்கு வில்லைகளை அனுப்பினால் அவை இன்னும் சிக்கிக்கொள்ளலாம்.
ஒரு செயல்பாட்டில் சிக்கல் ஏற்படும் போது, தோல்வி மதிப்பைத் திருப்பி அனுப்புவதை விட, அழைப்பை revert செய்வது (மீளமைப்பது) ஒரு நல்ல யோசனையாகும்.
ERC-721 வில்லைகளுக்கு ஒரு உரிமையாளர் இருக்கும்போது அவை உள்ளன.
ஒரு NFT-ஐப் பரிமாற்றம் செய்ய அங்கீகரிக்கப்பட மூன்று வழிகள் உள்ளன. நீங்கள் உரிமையாளராக இருக்கலாம், ஒரு குறிப்பிட்ட வில்லைக்கு ஒப்புதல் பெற்றிருக்கலாம் அல்லது உரிமையாளரின் அனைத்து வில்லைகளுக்கும் ஒரு ஆபரேட்டராக இருக்கலாம்.
கடந்த கால நிகழ்வுகள் தொகுதிச்சங்கிலிக்கு வெளியே மட்டுமே தெரியும். தொகுதிச்சங்கிலிக்குள் இயங்கும் குறியீட்டால் அவற்றைப் பார்க்க முடியாது.

இப்போது சென்று பாதுகாப்பான Vyper ஒப்பந்தங்களைச் செயல்படுத்துங்கள்.

எனது மேலும் பல பணிகளுக்கு இங்கே பார்க்கவும் (opens in a new tab).