யெல்லோ பேப்பரின் (Yellow Paper) EVM விவரக்குறிப்புகளைப் புரிந்துகொள்ளுதல்

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

எந்த யெல்லோ பேப்பர்?

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

ஏன் EVM?

அசல் யெல்லோ பேப்பர் எத்தேரியத்தின் வளர்ச்சியின் தொடக்கத்திலேயே எழுதப்பட்டது. நெட்வொர்க்கைப் பாதுகாக்க முதலில் பயன்படுத்தப்பட்ட அசல் ப்ரூஃப்-ஆஃப்-வொர்க் (proof-of-work) அடிப்படையிலான கருத்தொற்றுமை வழிமுறையை இது விவரிக்கிறது. இருப்பினும், எத்தேரியம் ப்ரூஃப்-ஆஃப்-வொர்க்கை நிறுத்திவிட்டு, செப்டம்பர் 2022 இல் ப்ரூஃப்-ஆஃப்-ஸ்டேக் (proof-of-stake) அடிப்படையிலான கருத்தொற்றுமையைப் பயன்படுத்தத் தொடங்கியது. இந்த டுடோரியல் எத்தேரியம் விர்ச்சுவல் மெஷினை (EVM) வரையறுக்கும் யெல்லோ பேப்பரின் பகுதிகளில் கவனம் செலுத்தும். ப்ரூஃப்-ஆஃப்-ஸ்டேக்கிற்கு மாறியதால் EVM மாறவில்லை (DIFFICULTY ஆப்கோடின் (opcode) ரிட்டர்ன் மதிப்பைத் தவிர).

9 செயலாக்க மாதிரி

இந்தப் பிரிவு (பக். 12-14) EVM-இன் பெரும்பாலான வரையறைகளை உள்ளடக்கியது.

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

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

டூரிங்-கம்ப்ளீட் (Turing-complete) (opens in a new tab) என்ற சொல், டூரிங் மெஷினைப் போலவே அதே கணக்கீடுகளை இயக்கக்கூடிய ஒரு கணினியைக் குறிக்கிறது. டூரிங் மெஷின்கள் முடிவற்ற லூப்களில் (infinite loops) சிக்கிக்கொள்ளலாம், ஆனால் EVM-ஆல் முடியாது, ஏனெனில் அதில் கேஸ் (gas) தீர்ந்துவிடும், எனவே இது குவாசி-டூரிங்-கம்ப்ளீட் (quasi-Turing-complete) மட்டுமே.

9.1 அடிப்படைகள்

இந்தப் பிரிவு EVM-இன் அடிப்படைகளையும், பிற கணக்கீட்டு மாதிரிகளுடன் அது எவ்வாறு ஒப்பிடப்படுகிறது என்பதையும் வழங்குகிறது.

ஸ்டாக் மெஷின் (stack machine) (opens in a new tab) என்பது இடைநிலைத் தரவை ரெஜிஸ்டர்களில் அல்லாமல், ஒரு ஸ்டாக்கில் (stack) (opens in a new tab) சேமிக்கும் ஒரு கணினியாகும். விர்ச்சுவல் மெஷின்களுக்கு இதுவே விருப்பமான கட்டமைப்பாகும், ஏனெனில் இதைச் செயல்படுத்துவது எளிது, அதாவது பிழைகள் மற்றும் பாதுகாப்பு பாதிப்புகள் ஏற்படுவதற்கான வாய்ப்புகள் மிகக் குறைவு. ஸ்டாக்கில் உள்ள மெமரி 256-பிட் வார்த்தைகளாகப் பிரிக்கப்பட்டுள்ளது. Keccak-256 ஹாஷிங் மற்றும் எலிப்டிக் கர்வ் (elliptic curve) கணக்கீடுகள் போன்ற எத்தேரியத்தின் முக்கிய கிரிப்டோகிராஃபிக் செயல்பாடுகளுக்கு இது வசதியாக இருப்பதால் இது தேர்ந்தெடுக்கப்பட்டது. ஸ்டாக்கின் அதிகபட்ச அளவு 1024 உருப்படிகள் (1024 x 256 பிட்கள்). ஆப்கோடுகள் (opcodes) செயல்படுத்தப்படும்போது, அவை வழக்கமாக அவற்றின் அளவுருக்களை ஸ்டாக்கிலிருந்து பெறுகின்றன. ஸ்டாக்கில் உள்ள கூறுகளை மறுசீரமைக்க POP (ஸ்டாக்கின் மேலிருந்து உருப்படியை அகற்றும்), DUP_N (ஸ்டாக்கில் N-ஆவது உருப்படியை நகலெடுக்கும்) போன்ற குறிப்பிட்ட ஆப்கோடுகள் உள்ளன.

EVM-இல் மெமரி (memory) எனப்படும் ஒரு தற்காலிக இடமும் உள்ளது, இது செயல்பாட்டின் போது தரவைச் சேமிக்கப் பயன்படுகிறது. இந்த மெமரி 32-பைட் வார்த்தைகளாக ஒழுங்கமைக்கப்பட்டுள்ளது. அனைத்து மெமரி இடங்களும் பூஜ்ஜியமாகத் தொடங்கப்படுகின்றன. மெமரியில் ஒரு வார்த்தையைச் சேர்க்க இந்த Yul (opens in a new tab) குறியீட்டை நீங்கள் இயக்கினால், அது வார்த்தையில் உள்ள காலி இடத்தை பூஜ்ஜியங்களால் நிரப்புவதன் மூலம் 32 பைட்டுகள் மெமரியை நிரப்பும், அதாவது, இது ஒரு வார்த்தையை உருவாக்குகிறது - 0-29 இடங்களில் பூஜ்ஜியங்கள், 30-இல் 0x60 மற்றும் 31-இல் 0xA7.

1mstore(0, 0x60A7)

மெமரியுடன் தொடர்புகொள்வதற்கு EVM வழங்கும் மூன்று ஆப்கோடுகளில் mstore ஒன்றாகும் - இது ஒரு வார்த்தையை மெமரியில் ஏற்றுகிறது. மற்ற இரண்டும் mstore8 ஆகும், இது ஒரு பைட்டை மெமரியில் ஏற்றுகிறது, மற்றும் mload ஆகும், இது ஒரு வார்த்தையை மெமரியிலிருந்து ஸ்டாக்கிற்கு நகர்த்துகிறது.

EVM-இல் சிஸ்டம் ஸ்டேட்டின் ஒரு பகுதியாகப் பராமரிக்கப்படும் ஒரு தனி தற்காலிகமற்ற ஸ்டோரேஜ் (storage) மாதிரியும் உள்ளது - இந்த மெமரி வார்த்தை வரிசைகளாக (word arrays) ஒழுங்கமைக்கப்பட்டுள்ளது (ஸ்டாக்கில் உள்ள வார்த்தை-முகவரியிடக்கூடிய பைட் வரிசைகளுக்கு மாறாக). இந்த ஸ்டோரேஜில்தான் ஒப்பந்தங்கள் நிலையான தரவை வைத்திருக்கின்றன - ஒரு ஒப்பந்தம் அதன் சொந்த ஸ்டோரேஜுடன் மட்டுமே தொடர்புகொள்ள முடியும். ஸ்டோரேஜ் கீ-வேல்யூ (key-value) மேப்பிங்குகளில் ஒழுங்கமைக்கப்பட்டுள்ளது.

யெல்லோ பேப்பரின் இந்தப் பிரிவில் இது குறிப்பிடப்படவில்லை என்றாலும், நான்காவது வகையான மெமரி இருப்பதையும் தெரிந்துகொள்வது பயனுள்ளதாக இருக்கும். கால்டேட்டா (Calldata) என்பது ஒரு பரிவர்த்தனையின் data அளவுருவுடன் அனுப்பப்படும் மதிப்பைச் சேமிக்கப் பயன்படுத்தப்படும் பைட்-முகவரியிடக்கூடிய படிக்க-மட்டுமேயான (read-only) மெமரியாகும். calldata-ஐ நிர்வகிக்க EVM-இல் குறிப்பிட்ட ஆப்கோடுகள் உள்ளன. calldatasize தரவின் அளவை வழங்குகிறது. calldataload தரவை ஸ்டாக்கில் ஏற்றுகிறது. calldatacopy தரவை மெமரியில் நகலெடுக்கிறது.

நிலையான வான் நியூமன் கட்டமைப்பு (Von Neumann architecture) (opens in a new tab) குறியீடு மற்றும் தரவை ஒரே மெமரியில் சேமிக்கிறது. பாதுகாப்பு காரணங்களுக்காக EVM இந்தத் தரநிலையைப் பின்பற்றுவதில்லை - தற்காலிக மெமரியைப் பகிர்வது நிரல் குறியீட்டை மாற்றுவதை சாத்தியமாக்குகிறது. அதற்குப் பதிலாக, குறியீடு ஸ்டோரேஜில் சேமிக்கப்படுகிறது.

மெமரியிலிருந்து குறியீடு செயல்படுத்தப்படும் இரண்டு நிகழ்வுகள் மட்டுமே உள்ளன:

• ஒரு ஒப்பந்தம் மற்றொரு ஒப்பந்தத்தை உருவாக்கும்போது (CREATE (opens in a new tab) அல்லது CREATE2 (opens in a new tab) ஐப் பயன்படுத்தி), ஒப்பந்த கன்ஸ்ட்ரக்டருக்கான (constructor) குறியீடு மெமரியிலிருந்து வருகிறது.
• எந்தவொரு ஒப்பந்தத்தையும் உருவாக்கும்போது, கன்ஸ்ட்ரக்டர் குறியீடு இயங்குகிறது, பின்னர் உண்மையான ஒப்பந்தத்தின் குறியீட்டுடன் திரும்புகிறது, இதுவும் மெமரியிலிருந்தே வருகிறது.

விதிவிலக்கான செயலாக்கம் (exceptional execution) என்ற சொல், தற்போதைய ஒப்பந்தத்தின் செயலாக்கத்தை நிறுத்தும் ஒரு விதிவிலக்கைக் குறிக்கிறது.

9.2 கட்டணங்கள் மேலோட்டம்

கேஸ் கட்டணங்கள் எவ்வாறு கணக்கிடப்படுகின்றன என்பதை இந்தப் பிரிவு விளக்குகிறது. மூன்று செலவுகள் உள்ளன:

ஆப்கோடு செலவு

குறிப்பிட்ட ஆப்கோடின் உள்ளார்ந்த செலவு. இந்த மதிப்பைப் பெற, பின்னிணைப்பு H-இல் (பக். 28, சமன்பாடு (327)-இன் கீழ்) ஆப்கோடின் செலவுக் குழுவைக் கண்டறியவும், மேலும் சமன்பாடு (324)-இல் செலவுக் குழுவைக் கண்டறியவும். இது உங்களுக்கு ஒரு செலவுச் செயல்பாட்டை (cost function) வழங்குகிறது, இது பெரும்பாலான சந்தர்ப்பங்களில் பின்னிணைப்பு G-இலிருந்து (பக். 27) அளவுருக்களைப் பயன்படுத்துகிறது.

எடுத்துக்காட்டாக, CALLDATACOPY (opens in a new tab) ஆப்கோடு W_copy குழுவின் உறுப்பினராகும். அந்தக் குழுவிற்கான ஆப்கோடு செலவு G_verylow+G_copy×⌈μ_s[2]÷32⌉ ஆகும். பின்னிணைப்பு G-ஐப் பார்க்கும்போது, இரண்டு மாறிலிகளும் 3 என்பதைக் காண்கிறோம், இது நமக்கு 3+3×⌈μ_s[2]÷32⌉ ஐ வழங்குகிறது.

நாம் இன்னும் ⌈μ_s[2]÷32⌉ என்ற கோவையை (expression) புரிந்துகொள்ள வேண்டும். வெளிப்புறப் பகுதியான ⌈ <value> ⌉ என்பது சீலிங் செயல்பாடு (ceiling function) ஆகும், இது ஒரு மதிப்பைக் கொடுத்தால், அந்த மதிப்பை விடச் சிறியதாக இல்லாத மிகச்சிறிய முழு எண்ணை வழங்கும் ஒரு செயல்பாடாகும். எடுத்துக்காட்டாக, ⌈2.5⌉ = ⌈3⌉ = 3. உட்புறப் பகுதி μ_s[2]÷32 ஆகும். பக். 3-இல் உள்ள பிரிவு 3-ஐப் (மரபுகள்) பார்க்கும்போது, μ என்பது மெஷின் ஸ்டேட் (machine state) ஆகும். மெஷின் ஸ்டேட் பக். 13-இல் உள்ள பிரிவு 9.4.1-இல் வரையறுக்கப்பட்டுள்ளது. அந்தப் பிரிவின்படி, மெஷின் ஸ்டேட் அளவுருக்களில் ஒன்று ஸ்டாக்கிற்கான s ஆகும். அனைத்தையும் ஒன்றாக இணைத்துப் பார்க்கும்போது, μ_s[2] என்பது ஸ்டாக்கில் உள்ள இடம் #2 என்று தோன்றுகிறது. ஆப்கோடைப் (opens in a new tab) பார்க்கும்போது, ஸ்டாக்கில் உள்ள இடம் #2 என்பது பைட்டுகளில் உள்ள தரவின் அளவாகும். W_copy குழுவில் உள்ள மற்ற ஆப்கோடுகளான CODECOPY (opens in a new tab) மற்றும் RETURNDATACOPY (opens in a new tab) ஆகியவற்றைப் பார்க்கும்போது, அவையும் அதே இடத்தில் தரவின் அளவைக் கொண்டுள்ளன. எனவே ⌈μ_s[2]÷32⌉ என்பது நகலெடுக்கப்படும் தரவைச் சேமிக்கத் தேவையான 32 பைட் வார்த்தைகளின் எண்ணிக்கையாகும். அனைத்தையும் ஒன்றாக இணைத்துப் பார்க்கும்போது, CALLDATACOPY (opens in a new tab) இன் உள்ளார்ந்த செலவு 3 கேஸ் மற்றும் நகலெடுக்கப்படும் தரவின் ஒவ்வொரு வார்த்தைக்கும் 3 ஆகும்.

இயங்கும் செலவு

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

• CREATE (opens in a new tab) மற்றும் CREATE2 (opens in a new tab) ஆகியவற்றின் விஷயத்தில், புதிய ஒப்பந்தத்திற்கான கன்ஸ்ட்ரக்டர்.
• CALL (opens in a new tab), CALLCODE (opens in a new tab), STATICCALL (opens in a new tab), அல்லது DELEGATECALL (opens in a new tab) ஆகியவற்றின் விஷயத்தில், நாம் அழைக்கும் ஒப்பந்தம்.

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

மெமரியை விரிவுபடுத்துவதற்கான செலவு (தேவைப்பட்டால்).

சமன்பாடு 324-இல், இந்த மதிப்பு C_mem(μ_i')-C_mem(μ_i) என எழுதப்பட்டுள்ளது. மீண்டும் பிரிவு 9.4.1-ஐப் பார்க்கும்போது, μ_i என்பது மெமரியில் உள்ள வார்த்தைகளின் எண்ணிக்கை என்பதைக் காண்கிறோம். எனவே μ_i என்பது ஆப்கோடிற்கு முன் மெமரியில் உள்ள வார்த்தைகளின் எண்ணிக்கை மற்றும் μ_i' என்பது ஆப்கோடிற்குப் பின் மெமரியில் உள்ள வார்த்தைகளின் எண்ணிக்கை.

C_mem செயல்பாடு சமன்பாடு 326-இல் வரையறுக்கப்பட்டுள்ளது: C_mem(a) = G_memory × a + ⌊a² ÷ 512⌋. ⌊x⌋ என்பது ஃப்ளோர் செயல்பாடு (floor function) ஆகும், இது ஒரு மதிப்பைக் கொடுத்தால், அந்த மதிப்பை விடப் பெரியதாக இல்லாத மிகப்பெரிய முழு எண்ணை வழங்கும் ஒரு செயல்பாடாகும். எடுத்துக்காட்டாக, ⌊2.5⌋ = ⌊2⌋ = 2. a < √512 ஆக இருக்கும்போது, a² < 512 ஆகும், மேலும் ஃப்ளோர் செயல்பாட்டின் முடிவு பூஜ்ஜியமாகும். எனவே முதல் 22 வார்த்தைகளுக்கு (704 பைட்டுகள்), தேவையான மெமரி வார்த்தைகளின் எண்ணிக்கையுடன் செலவு நேர்கோட்டில் உயர்கிறது. அந்தப் புள்ளிக்கு அப்பால் ⌊a² ÷ 512⌋ நேர்மறையானது. தேவையான மெமரி போதுமான அளவு அதிகமாக இருக்கும்போது, கேஸ் செலவு மெமரியின் அளவின் வர்க்கத்திற்கு (square) விகிதாசாரமாக இருக்கும்.

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

கேஸ் பற்றி மேலும் படிக்க.

9.3 செயலாக்கச் சூழல்

செயலாக்கச் சூழல் (execution environment) என்பது ஒரு டியூப்பிள் (tuple), I ஆகும், இது பிளாக்செயின் ஸ்டேட் அல்லது EVM-இன் பகுதியாக இல்லாத தகவல்களை உள்ளடக்கியது.

பிரிவு 9-இன் மீதமுள்ள பகுதியைப் புரிந்துகொள்ள வேறு சில அளவுருக்கள் அவசியம்:

9.4 செயலாக்க மேலோட்டம்

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

சமன்பாடுகள் 137-142 EVM-ஐ இயக்குவதற்கான ஆரம்ப நிபந்தனைகளை நமக்கு வழங்குகின்றன:

செயல்பாட்டின் போது ஒவ்வொரு நேரத்திலும் நான்கு சாத்தியமான நிபந்தனைகள் உள்ளன என்பதையும், அவற்றுடன் என்ன செய்ய வேண்டும் என்பதையும் சமன்பாடு 143 நமக்குக் கூறுகிறது:

1. Z(σ,μ,A,I). ஒரு செயல்பாடு தவறான ஸ்டேட் மாற்றத்தை உருவாக்குகிறதா என்பதைச் சோதிக்கும் ஒரு செயல்பாட்டை Z குறிக்கிறது (விதிவிலக்கான நிறுத்தம் என்பதைப் பார்க்கவும்). இது True என மதிப்பிடப்பட்டால், மாற்றங்கள் செயல்படுத்தப்படாததால் புதிய ஸ்டேட் பழையதைப் போலவே இருக்கும் (கேஸ் எரிக்கப்படுவதைத் தவிர).
2. செயல்படுத்தப்படும் ஆப்கோடு REVERT (opens in a new tab) ஆக இருந்தால், புதிய ஸ்டேட் பழைய ஸ்டேட்டைப் போலவே இருக்கும், சிறிது கேஸ் இழக்கப்படும்.
3. செயல்பாடுகளின் வரிசை முடிவடைந்தால், அது RETURN (opens in a new tab) மூலம் குறிக்கப்படும், ஸ்டேட் புதிய ஸ்டேட்டிற்குப் புதுப்பிக்கப்படும்.
4. நாம் 1-3 இறுதி நிபந்தனைகளில் ஒன்றில் இல்லை என்றால், தொடர்ந்து இயக்கவும்.

9.4.1 மெஷின் ஸ்டேட்

இந்தப் பிரிவு மெஷின் ஸ்டேட்டை இன்னும் விரிவாக விளக்குகிறது. w என்பது தற்போதைய ஆப்கோடு என்பதை இது குறிப்பிடுகிறது. μ_pc ஆனது குறியீட்டின் நீளமான ||I_b|| ஐ விடக் குறைவாக இருந்தால், அந்த பைட் (I_b[μ_pc]) ஆப்கோடு ஆகும். இல்லையெனில், ஆப்கோடு STOP (opens in a new tab) என வரையறுக்கப்படுகிறது.

இது ஒரு ஸ்டாக் மெஷின் (opens in a new tab) என்பதால், ஒவ்வொரு ஆப்கோடும் வெளியேற்றும் (δ) மற்றும் உள்ளே தள்ளும் (α) உருப்படிகளின் எண்ணிக்கையை நாம் கண்காணிக்க வேண்டும்.

9.4.2 விதிவிலக்கான நிறுத்தம்

இந்தப் பிரிவு Z செயல்பாட்டை வரையறுக்கிறது, இது எப்போது அசாதாரணமான நிறுத்தம் ஏற்படுகிறது என்பதைக் குறிப்பிடுகிறது. இது ஒரு பூலியன் (Boolean) (opens in a new tab) செயல்பாடாகும், எனவே இது லாஜிக்கல் or-க்கு ∨ ஐயும் (opens in a new tab) லாஜிக்கல் and-க்கு ∧ ஐயும் (opens in a new tab) பயன்படுத்துகிறது.

இந்த நிபந்தனைகளில் ஏதேனும் ஒன்று உண்மையாக இருந்தால் நமக்கு ஒரு விதிவிலக்கான நிறுத்தம் ஏற்படும்:

• μ_g < C(σ,μ,A,I) பிரிவு 9.2-இல் நாம் பார்த்தபடி, C என்பது கேஸ் செலவைக் குறிப்பிடும் செயல்பாடாகும். அடுத்த ஆப்கோடை ஈடுகட்டப் போதுமான கேஸ் மீதமில்லை.

• δ_w=∅ ஒரு ஆப்கோடிற்கு வெளியேற்றப்பட்ட உருப்படிகளின் எண்ணிக்கை வரையறுக்கப்படவில்லை என்றால், ஆப்கோடும் வரையறுக்கப்படவில்லை.

• || μ_s || < δ_w ஸ்டாக் அண்டர்ஃப்ளோ (Stack underflow), தற்போதைய ஆப்கோடிற்கு ஸ்டாக்கில் போதுமான உருப்படிகள் இல்லை.

• w = JUMP ∧ μ_s[0]∉D(I_b) ஆப்கோடு JUMP (opens in a new tab) ஆகும் மற்றும் முகவரி ஒரு JUMPDEST (opens in a new tab) அல்ல. இலக்கு ஒரு JUMPDEST (opens in a new tab) ஆக இருக்கும்போது மட்டுமே ஜம்ப்கள் (Jumps) செல்லுபடியாகும்.

• w = JUMPI ∧ μ_s[1]≠0 ∧ μ_s[0] ∉ D(I_b) ஆப்கோடு JUMPI (opens in a new tab) ஆகும், நிபந்தனை உண்மை (பூஜ்ஜியமற்றது) எனவே ஜம்ப் நிகழ வேண்டும், மற்றும் முகவரி ஒரு JUMPDEST (opens in a new tab) அல்ல. இலக்கு ஒரு JUMPDEST (opens in a new tab) ஆக இருக்கும்போது மட்டுமே ஜம்ப்கள் செல்லுபடியாகும்.

• w = RETURNDATACOPY ∧ μ_s[1]+μ_s[2]>|| μ_o || ஆப்கோடு RETURNDATACOPY (opens in a new tab) ஆகும். இந்த ஆப்கோடில் ஸ்டாக் உறுப்பு μ_s[1] என்பது ரிட்டர்ன் தரவு பஃபரில் (buffer) படிக்க வேண்டிய ஆஃப்செட் (offset) ஆகும், மற்றும் ஸ்டாக் உறுப்பு μ_s[2] என்பது தரவின் நீளமாகும். ரிட்டர்ன் தரவு பஃபரின் முடிவிற்கு அப்பால் படிக்க முயற்சிக்கும்போது இந்த நிபந்தனை ஏற்படுகிறது. கால்டேட்டா அல்லது குறியீட்டிற்கு இதே போன்ற நிபந்தனை இல்லை என்பதைக் கவனிக்கவும். அந்த பஃபர்களின் முடிவிற்கு அப்பால் படிக்க முயற்சிக்கும்போது உங்களுக்குப் பூஜ்ஜியங்கள் மட்டுமே கிடைக்கும்.

• || μ_s || - δ_w + α_w > 1024

  ஸ்டாக் ஓவர்ஃப்ளோ (Stack overflow). ஆப்கோடை இயக்குவது 1024 உருப்படிகளுக்கு மேல் உள்ள ஸ்டாக்கை விளைவித்தால், கைவிடவும்.

• ¬I_w ∧ W(w,μ) நாம் நிலையாக இயங்குகிறோமா (¬ என்பது மறுப்பு (opens in a new tab) மற்றும் பிளாக்செயின் ஸ்டேட்டை மாற்ற அனுமதிக்கப்படும்போது I_w உண்மையாக இருக்கும்)? அப்படியானால், நாம் ஒரு ஸ்டேட் மாற்றும் செயல்பாட்டை முயற்சிக்கிறோம் என்றால், அது நடக்க முடியாது.

  W(w,μ) செயல்பாடு பின்னர் சமன்பாடு 150-இல் வரையறுக்கப்பட்டுள்ளது. இந்த நிபந்தனைகளில் ஏதேனும் ஒன்று உண்மையாக இருந்தால் W(w,μ) உண்மையாக இருக்கும்:

  • w ∈ {CREATE, CREATE2, SSTORE, SELFDESTRUCT} இந்த ஆப்கோடுகள் ஒரு புதிய ஒப்பந்தத்தை உருவாக்குவதன் மூலமாகவோ, ஒரு மதிப்பைச் சேமிப்பதன் மூலமாகவோ அல்லது தற்போதைய ஒப்பந்தத்தை அழிப்பதன் மூலமாகவோ ஸ்டேட்டை மாற்றுகின்றன.

  • LOG0≤w ∧ w≤LOG4 நாம் நிலையாக அழைக்கப்பட்டால் நம்மால் லாக் (log) உள்ளீடுகளை வெளியிட முடியாது. லாக் ஆப்கோடுகள் அனைத்தும் LOG0 (A0) (opens in a new tab) மற்றும் LOG4 (A4) (opens in a new tab) ஆகியவற்றுக்கு இடையேயான வரம்பில் உள்ளன. லாக் ஆப்கோடிற்குப் பின் உள்ள எண், லாக் உள்ளீட்டில் எத்தனை தலைப்புகள் உள்ளன என்பதைக் குறிப்பிடுகிறது.

  • w=CALL ∧ μ_s[2]≠0 நீங்கள் நிலையாக இருக்கும்போது மற்றொரு ஒப்பந்தத்தை அழைக்கலாம், ஆனால் அவ்வாறு செய்தால் உங்களால் அதற்கு ETH-ஐ மாற்ற முடியாது.

• w = SSTORE ∧ μ_g ≤ G_callstipend உங்களிடம் G_callstipend (பின்னிணைப்பு G-இல் 2300 என வரையறுக்கப்பட்டுள்ளது) கேஸை விட அதிகமாக இல்லாவிட்டால் உங்களால் SSTORE (opens in a new tab) ஐ இயக்க முடியாது.

9.4.3 ஜம்ப் இலக்கு செல்லுபடியாகும் தன்மை

JUMPDEST (opens in a new tab) ஆப்கோடுகள் என்றால் என்ன என்பதை இங்கே நாம் முறையாக வரையறுக்கிறோம். நாம் பைட் மதிப்பு 0x5B-ஐ மட்டும் தேட முடியாது, ஏனெனில் அது ஒரு PUSH-க்குள் இருக்கலாம் (எனவே அது தரவு, ஆப்கோடு அல்ல).

சமன்பாடு (153)-இல் நாம் N(i,w) என்ற செயல்பாட்டை வரையறுக்கிறோம். முதல் அளவுரு, i, ஆப்கோடின் இருப்பிடமாகும். இரண்டாவது, w, ஆப்கோடே ஆகும். w∈[PUSH1, PUSH32] ஆக இருந்தால், ஆப்கோடு ஒரு PUSH என்று அர்த்தம் (சதுர அடைப்புக்குறிகள் இறுதிப்புள்ளிகளை உள்ளடக்கிய ஒரு வரம்பை வரையறுக்கின்றன). அந்த நிலையில் அடுத்த ஆப்கோடு i+2+(w−PUSH1)-இல் இருக்கும். PUSH1 (opens in a new tab)-க்கு நாம் இரண்டு பைட்டுகள் (PUSH மற்றும் ஒரு பைட் மதிப்பு) முன்னேற வேண்டும், PUSH2 (opens in a new tab)-க்கு நாம் மூன்று பைட்டுகள் முன்னேற வேண்டும், ஏனெனில் அது இரண்டு பைட் மதிப்பு, போன்றவை. மற்ற அனைத்து EVM ஆப்கோடுகளும் ஒரு பைட் நீளம் மட்டுமே கொண்டவை, எனவே மற்ற எல்லா சந்தர்ப்பங்களிலும் N(i,w)=i+1.

குறியீடு c-இல், ஆப்கோடு இருப்பிடம் i-இல் தொடங்கி, செல்லுபடியாகும் அனைத்து ஜம்ப் இலக்குகளின் தொகுப்பான (set) (opens in a new tab) D_J(c,i)-ஐ வரையறுக்க இந்தச் செயல்பாடு சமன்பாடு (152)-இல் பயன்படுத்தப்படுகிறது. இந்தச் செயல்பாடு சுழல்முறையாக (recursively) வரையறுக்கப்பட்டுள்ளது. i≥||c|| ஆக இருந்தால், நாம் குறியீட்டின் முடிவில் அல்லது அதற்குப் பிறகு இருக்கிறோம் என்று அர்த்தம். நாம் இனி எந்த ஜம்ப் இலக்குகளையும் கண்டுபிடிக்கப் போவதில்லை, எனவே வெற்றுத் தொகுப்பை மட்டும் வழங்கவும்.

மற்ற எல்லா சந்தர்ப்பங்களிலும், அடுத்த ஆப்கோடிற்குச் சென்று அதிலிருந்து தொடங்கும் தொகுப்பைப் பெறுவதன் மூலம் குறியீட்டின் மீதமுள்ள பகுதியைப் பார்க்கிறோம். c[i] என்பது தற்போதைய ஆப்கோடு ஆகும், எனவே N(i,c[i]) என்பது அடுத்த ஆப்கோடின் இருப்பிடமாகும். எனவே D_J(c,N(i,c[i])) என்பது அடுத்த ஆப்கோடில் தொடங்கும் செல்லுபடியாகும் ஜம்ப் இலக்குகளின் தொகுப்பாகும். தற்போதைய ஆப்கோடு ஒரு JUMPDEST ஆக இல்லாவிட்டால், அந்தத் தொகுப்பை மட்டும் வழங்கவும். அது JUMPDEST ஆக இருந்தால், அதை முடிவுத் தொகுப்பில் சேர்த்து அதை வழங்கவும்.

9.4.4 சாதாரண நிறுத்தம்

நிறுத்தும் செயல்பாடு H, மூன்று வகையான மதிப்புகளை வழங்க முடியும்.

• நாம் ஒரு ஹால்ட் (halt) ஆப்கோடில் இல்லை என்றால், வெற்றுத் தொகுப்பான ∅-ஐ வழங்கவும். மரபுப்படி, இந்த மதிப்பு பூலியன் false எனப் பொருள் கொள்ளப்படுகிறது.
• வெளியீட்டை உருவாக்காத ஒரு ஹால்ட் ஆப்கோடு நம்மிடம் இருந்தால் (STOP (opens in a new tab) அல்லது SELFDESTRUCT (opens in a new tab)), பூஜ்ஜிய பைட்டுகள் அளவுள்ள ஒரு வரிசையை ரிட்டர்ன் மதிப்பாக வழங்கவும். இது வெற்றுத் தொகுப்பிலிருந்து மிகவும் வேறுபட்டது என்பதைக் கவனிக்கவும். இந்த மதிப்பு EVM உண்மையில் நின்றுவிட்டது என்பதைக் குறிக்கிறது, படிக்க எந்த ரிட்டர்ன் தரவும் இல்லை.
• வெளியீட்டை உருவாக்கும் ஒரு ஹால்ட் ஆப்கோடு நம்மிடம் இருந்தால் (RETURN (opens in a new tab) அல்லது REVERT (opens in a new tab)), அந்த ஆப்கோடால் குறிப்பிடப்பட்ட பைட்டுகளின் வரிசையை வழங்கவும். இந்த வரிசை மெமரியிலிருந்து எடுக்கப்படுகிறது, ஸ்டாக்கின் மேலேயுள்ள மதிப்பு (μ_s[0]) முதல் பைட் ஆகும், மேலும் அதற்குப் பின் உள்ள மதிப்பு (μ_s[1]) நீளமாகும்.

H.2 அறிவுறுத்தல் தொகுப்பு

EVM-இன் இறுதி துணைப்பிரிவான 9.5-க்குச் செல்வதற்கு முன், அறிவுறுத்தல்களைப் பார்ப்போம். அவை பக். 29-இல் தொடங்கும் பின்னிணைப்பு H.2-இல் வரையறுக்கப்பட்டுள்ளன. அந்தக் குறிப்பிட்ட ஆப்கோடுடன் மாறுவதாகக் குறிப்பிடப்படாத எதுவும் அப்படியே இருக்கும் என்று எதிர்பார்க்கப்படுகிறது. மாறும் மாறிகள் <something>′ எனக் குறிப்பிடப்படுகின்றன.

எடுத்துக்காட்டாக, ADD (opens in a new tab) ஆப்கோடைப் பார்ப்போம்.

δ என்பது ஸ்டாக்கிலிருந்து நாம் வெளியேற்றும் மதிப்புகளின் எண்ணிக்கையாகும். இந்த விஷயத்தில் இரண்டு, ஏனெனில் நாம் மேலேயுள்ள இரண்டு மதிப்புகளைக் கூட்டுகிறோம்.

α என்பது நாம் மீண்டும் உள்ளே தள்ளும் மதிப்புகளின் எண்ணிக்கையாகும். இந்த விஷயத்தில் ஒன்று, அது கூட்டல் தொகை.

எனவே புதிய ஸ்டாக்கின் மேல் பகுதி (μ′_s[0]) என்பது பழைய ஸ்டாக்கின் மேல் பகுதி (μ_s[0]) மற்றும் அதற்குக் கீழே உள்ள பழைய மதிப்பு (μ_s[1]) ஆகியவற்றின் கூட்டல் தொகையாகும்.

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

மெமரியை அணுகும் முதல் ஆப்கோடு இதுவாகும் (இந்த விஷயத்தில், படிக்க மட்டுமே). இருப்பினும், இது மெமரியின் தற்போதைய வரம்புகளுக்கு அப்பால் விரிவடையக்கூடும், எனவே நாம் μ_i-ஐப் புதுப்பிக்க வேண்டும். பக். 29-இல் உள்ள சமன்பாடு 328-இல் வரையறுக்கப்பட்டுள்ள M செயல்பாட்டைப் பயன்படுத்தி இதைச் செய்கிறோம்.

நாம் இருப்பைக் கண்டறிய வேண்டிய முகவரி μ_s[0] mod 2¹⁶⁰ ஆகும். ஸ்டாக்கின் மேல் பகுதி முகவரியாகும், ஆனால் முகவரிகள் 160 பிட்கள் மட்டுமே என்பதால், நாம் மதிப்பை 2¹⁶⁰ மாடுலோ (modulo) (opens in a new tab) மூலம் கணக்கிடுகிறோம்.

σ[μ_s[0] mod 2¹⁶⁰] ≠ ∅ ஆக இருந்தால், இந்த முகவரியைப் பற்றிய தகவல் உள்ளது என்று அர்த்தம். அந்த நிலையில், σ[μ_s[0] mod 2¹⁶⁰]_b என்பது அந்த முகவரிக்கான இருப்பாகும். σ[μ_s[0] mod 2¹⁶⁰] = ∅ ஆக இருந்தால், இந்த முகவரி தொடங்கப்படவில்லை மற்றும் இருப்பு பூஜ்ஜியமாகும் என்று அர்த்தம். பக். 4-இல் உள்ள பிரிவு 4.1-இல் கணக்குத் தகவல் புலங்களின் பட்டியலை நீங்கள் காணலாம்.

இரண்டாவது சமன்பாடு, A'_a ≡ A_a ∪ {μ_s[0] mod 2¹⁶⁰}, வார்ம் ஸ்டோரேஜ் (சமீபத்தில் அணுகப்பட்ட மற்றும் கேச் (cache) செய்யப்பட்டிருக்கக்கூடிய ஸ்டோரேஜ்) மற்றும் கோல்ட் ஸ்டோரேஜ் (அணுகப்படாத மற்றும் மீட்டெடுக்க அதிக செலவாகும் மெதுவான ஸ்டோரேஜில் இருக்கக்கூடிய ஸ்டோரேஜ்) ஆகியவற்றை அணுகுவதற்கான செலவு வேறுபாட்டுடன் தொடர்புடையது. A_a என்பது பரிவர்த்தனையால் முன்பு அணுகப்பட்ட முகவரிகளின் பட்டியலாகும், எனவே பக். 8-இல் உள்ள பிரிவு 6.1-இல் வரையறுக்கப்பட்டுள்ளபடி, இதை அணுகுவது மலிவானதாக இருக்க வேண்டும். இந்தத் தலைப்பைப் பற்றி EIP-2929 (opens in a new tab)-இல் நீங்கள் மேலும் படிக்கலாம்.

எந்தவொரு ஸ்டாக் உருப்படியையும் பயன்படுத்த, நாம் அதை வெளியேற்ற வேண்டும், அதாவது அதன் மேல் உள்ள அனைத்து ஸ்டாக் உருப்படிகளையும் நாம் வெளியேற்ற வேண்டும் என்பதைக் கவனிக்கவும். DUP<n> (opens in a new tab) மற்றும் SWAP<n> (opens in a new tab) ஆகியவற்றின் விஷயத்தில், பதினாறு மதிப்புகள் வரை வெளியேற்றி பின்னர் உள்ளே தள்ள வேண்டும் என்று அர்த்தம்.

9.5 செயலாக்கச் சுழற்சி

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

சமன்பாடு (155) கொடுக்கப்பட்ட ஸ்டேட்டைக் கூறுகிறது:

• σ (உலகளாவிய பிளாக்செயின் ஸ்டேட்)
• μ (EVM ஸ்டேட்)
• A (சப்ஸ்டேட், பரிவர்த்தனை முடிவடையும் போது நிகழ வேண்டிய மாற்றங்கள்)
• I (செயலாக்கச் சூழல்)

புதிய ஸ்டேட் (σ', μ', A', I') ஆகும்.

சமன்பாடுகள் (156)-(158) ஸ்டாக் மற்றும் ஒரு ஆப்கோடால் (μ_s) அதில் ஏற்படும் மாற்றத்தை வரையறுக்கின்றன. சமன்பாடு (159) என்பது கேஸில் ஏற்படும் மாற்றம் (μ_g). சமன்பாடு (160) என்பது புரோகிராம் கவுண்டரில் ஏற்படும் மாற்றம் (μ_pc). இறுதியாக, சமன்பாடுகள் (161)-(164) ஆப்கோடால் வெளிப்படையாக மாற்றப்படாவிட்டால், மற்ற அளவுருக்கள் அப்படியே இருக்கும் என்பதைக் குறிப்பிடுகின்றன.

இதனுடன் EVM முழுமையாக வரையறுக்கப்பட்டுள்ளது.

முடிவுரை

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

• இதை மனிதர்களால் மட்டுமே புரிந்துகொள்ள முடியும், அதாவது இணக்கச் சோதனைகள் (compliance tests) (opens in a new tab) கைமுறையாக எழுதப்பட வேண்டும்.
• புரோகிராமர்கள் கணினிக் குறியீட்டைப் புரிந்துகொள்கிறார்கள். அவர்கள் கணிதக் குறியீட்டைப் புரிந்துகொள்ளலாம் அல்லது புரிந்துகொள்ளாமலும் இருக்கலாம்.

ஒருவேளை இந்தக் காரணங்களுக்காக, புதிய கருத்தொற்றுமை லேயர் விவரக்குறிப்புகள் (consensus layer specs) (opens in a new tab) பைத்தானில் (Python) எழுதப்பட்டுள்ளன. பைத்தானில் செயலாக்க லேயர் விவரக்குறிப்புகள் (execution layer specs) (opens in a new tab) உள்ளன, ஆனால் அவை முழுமையடையவில்லை. முழு யெல்லோ பேப்பரும் பைத்தான் அல்லது அதைப் போன்ற ஒரு மொழிக்கு மொழிபெயர்க்கப்படும் வரை, யெல்லோ பேப்பர் தொடர்ந்து சேவையில் இருக்கும், மேலும் அதைப் படிக்க முடிவது உதவியாக இருக்கும்.

பக்கம் கடைசியாகப் புதுப்பிக்கப்பட்டது: 3 மார்ச், 2026

m (opens in a new tab)

s (opens in a new tab)

p (opens in a new tab)

+9

பங்களிப்பாளர்களைப் பார்க்கவும்