ఎల్లో పేపర్ యొక్క EVM స్పెసిఫికేషన్లను అర్థం చేసుకోవడం

ఎల్లో పేపర్ (opens in a new tab) అనేది ఎథీరియం యొక్క అధికారిక స్పెసిఫికేషన్. EIP ప్రక్రియ ద్వారా సవరించబడిన చోట మినహా, ప్రతిదీ ఎలా పనిచేస్తుందో ఖచ్చితమైన వివరణను ఇది కలిగి ఉంటుంది. ఇది గణితశాస్త్ర పత్రంగా వ్రాయబడింది, ఇందులో ప్రోగ్రామర్లకు పరిచయం లేని పదజాలం ఉండవచ్చు. ఈ పత్రంలో మీరు దానిని ఎలా చదవాలో మరియు దాని ద్వారా ఇతర సంబంధిత గణిత పత్రాలను ఎలా చదవాలో నేర్చుకుంటారు.

ఏ ఎల్లో పేపర్?

ఎథీరియంలోని దాదాపు ప్రతిదానిలాగే, ఎల్లో పేపర్ కూడా కాలక్రమేణా అభివృద్ధి చెందుతుంది. ఒక నిర్దిష్ట వెర్షన్‌ను సూచించడానికి, నేను వ్రాసే సమయానికి ఉన్న ప్రస్తుత వెర్షన్‌ను అప్‌లోడ్ చేసాను. నేను ఉపయోగించే విభాగం, పేజీ మరియు సమీకరణ సంఖ్యలు ఆ వెర్షన్‌ను సూచిస్తాయి. ఈ పత్రాన్ని చదువుతున్నప్పుడు దానిని వేరే విండోలో తెరిచి ఉంచడం మంచిది.

EVM ఎందుకు?

అసలు ఎల్లో పేపర్ ఎథీరియం అభివృద్ధి ప్రారంభంలోనే వ్రాయబడింది. నెట్‌వర్క్‌ను సురక్షితం చేయడానికి మొదట ఉపయోగించిన అసలు ప్రూఫ్-ఆఫ్-వర్క్ (PoW) ఆధారిత ఏకాభిప్రాయ యంత్రాంగం గురించి ఇది వివరిస్తుంది. అయితే, ఎథీరియం ప్రూఫ్-ఆఫ్-వర్క్ (PoW)ను నిలిపివేసి, సెప్టెంబర్ 2022లో ప్రూఫ్-ఆఫ్-స్టేక్ (PoS) ఆధారిత ఏకాభిప్రాయాన్ని ఉపయోగించడం ప్రారంభించింది. ఈ ట్యుటోరియల్ ఎథీరియం వర్చువల్ మెషీన్‌ను నిర్వచించే ఎల్లో పేపర్ భాగాలపై దృష్టి పెడుతుంది. ప్రూఫ్-ఆఫ్-స్టేక్ (PoS)కి మారడం వల్ల EVM మారలేదు (DIFFICULTY ఆప్‌కోడ్ యొక్క రిటర్న్ విలువ మినహా).

9 అమలు నమూనా

ఈ విభాగం (పేజీ 12-14) EVM యొక్క చాలా నిర్వచనాలను కలిగి ఉంటుంది.

సిస్టమ్ స్థితి (system state) అనే పదం సిస్టమ్‌ను అమలు చేయడానికి మీరు తెలుసుకోవలసిన ప్రతిదాన్ని కలిగి ఉంటుంది. సాధారణ కంప్యూటర్‌లో, దీని అర్థం మెమరీ, రిజిస్టర్‌ల కంటెంట్ మొదలైనవి.

ట్యూరింగ్ మెషీన్ (opens in a new tab) అనేది ఒక గణన నమూనా. ముఖ్యంగా, ఇది కంప్యూటర్ యొక్క సరళీకృత వెర్షన్, ఇది సాధారణ కంప్యూటర్ చేయగల గణనలను అమలు చేయగల సామర్థ్యాన్ని కలిగి ఉందని నిరూపించబడింది (కంప్యూటర్ లెక్కించగల ప్రతిదాన్ని ట్యూరింగ్ మెషీన్ లెక్కించగలదు మరియు దీనికి విరుద్ధంగా కూడా). ఏది లెక్కించదగినది మరియు ఏది కాదు అనే దాని గురించి వివిధ సిద్ధాంతాలను నిరూపించడాన్ని ఈ నమూనా సులభతరం చేస్తుంది.

ట్యూరింగ్-కంప్లీట్ (opens in a new tab) అనే పదానికి ట్యూరింగ్ మెషీన్ వలె అదే గణనలను అమలు చేయగల కంప్యూటర్ అని అర్థం. ట్యూరింగ్ మెషీన్లు అనంతమైన లూప్‌లలోకి వెళ్లగలవు, కానీ EVM అలా చేయలేదు ఎందుకంటే దాని గ్యాస్ అయిపోతుంది, కాబట్టి ఇది పాక్షికంగా మాత్రమే ట్యూరింగ్-కంప్లీట్ (quasi-Turing-complete).

9.1 ప్రాథమిక అంశాలు

ఈ విభాగం EVM యొక్క ప్రాథమికాలను మరియు ఇతర గణన నమూనాలతో ఇది ఎలా పోల్చబడుతుందో తెలియజేస్తుంది.

స్టాక్ మెషీన్ (opens in a new tab) అనేది ఇంటర్మీడియట్ డేటాను రిజిస్టర్‌లలో కాకుండా స్టాక్ (opens in a new tab)లో నిల్వ చేసే కంప్యూటర్. వర్చువల్ మెషీన్‌లకు ఇది ప్రాధాన్యతనిచ్చే ఆర్కిటెక్చర్ ఎందుకంటే దీనిని అమలు చేయడం సులభం, అంటే బగ్‌లు మరియు భద్రతా లోపాలు చాలా తక్కువగా ఉంటాయి. స్టాక్‌లోని మెమరీ 256-బిట్ పదాలుగా విభజించబడింది. కేకాక్-256 హాషింగ్ మరియు దీర్ఘవృత్తాకార వక్రరేఖ గణనల వంటి ఎథీరియం యొక్క ప్రధాన క్రిప్టోగ్రాఫిక్ కార్యకలాపాలకు ఇది సౌకర్యవంతంగా ఉన్నందున ఇది ఎంచుకోబడింది. స్టాక్ యొక్క గరిష్ట పరిమాణం 1024 అంశాలు (1024 x 256 బిట్స్). ఆప్‌కోడ్‌లు అమలు చేయబడినప్పుడు అవి సాధారణంగా స్టాక్ నుండి వాటి పారామితులను పొందుతాయి. స్టాక్‌లోని మూలకాలను పునర్వ్యవస్థీకరించడానికి ప్రత్యేకంగా ఆప్‌కోడ్‌లు ఉన్నాయి, ఉదాహరణకు POP (స్టాక్ పైభాగం నుండి అంశాన్ని తీసివేస్తుంది), DUP_N (స్టాక్‌లోని Nవ అంశాన్ని నకిలీ చేస్తుంది) మొదలైనవి.

EVM అమలు సమయంలో డేటాను నిల్వ చేయడానికి ఉపయోగించే మెమరీ అనే అస్థిర స్థలాన్ని కూడా కలిగి ఉంటుంది. ఈ మెమరీ 32-బైట్ పదాలుగా నిర్వహించబడుతుంది. అన్ని మెమరీ స్థానాలు సున్నాకి ప్రారంభించబడతాయి. మెమరీకి ఒక పదాన్ని జోడించడానికి మీరు ఈ Yul (opens in a new tab) కోడ్‌ను అమలు చేస్తే, అది పదంలోని ఖాళీ స్థలాన్ని సున్నాలతో నింపడం ద్వారా 32 బైట్ల మెమరీని నింపుతుంది, అనగా, ఇది ఒక పదాన్ని సృష్టిస్తుంది - 0-29 స్థానాల్లో సున్నాలతో, 30కి 0x60, మరియు 31కి 0xA7.

mstore(0, 0x60A7)

మెమరీతో ఇంటరాక్ట్ అవ్వడానికి EVM అందించే మూడు ఆప్‌కోడ్‌లలో mstore ఒకటి - ఇది మెమరీలోకి ఒక పదాన్ని లోడ్ చేస్తుంది. మిగిలిన రెండు mstore8 ఇది మెమరీలోకి ఒకే బైట్‌ను లోడ్ చేస్తుంది మరియు mload ఇది మెమరీ నుండి స్టాక్‌కి ఒక పదాన్ని తరలిస్తుంది.

EVM సిస్టమ్ స్థితిలో భాగంగా నిర్వహించబడే ప్రత్యేక నాన్-వొలటైల్ స్టోరేజ్ నమూనాను కూడా కలిగి ఉంది - ఈ మెమరీ వర్డ్ అర్రేలుగా నిర్వహించబడుతుంది (స్టాక్‌లోని వర్డ్-అడ్రస్ చేయగల బైట్ అర్రేలకు విరుద్ధంగా). ఈ స్టోరేజ్‌లోనే కాంట్రాక్ట్‌లు నిరంతర డేటాను ఉంచుతాయి - ఒక కాంట్రాక్ట్ దాని స్వంత స్టోరేజ్‌తో మాత్రమే ఇంటరాక్ట్ అవుతుంది. స్టోరేజ్ కీ-వాల్యూ మ్యాపింగ్‌లలో నిర్వహించబడుతుంది.

ఎల్లో పేపర్‌లోని ఈ విభాగంలో పేర్కొనబడనప్పటికీ, నాల్గవ రకం మెమరీ ఉందని తెలుసుకోవడం కూడా ఉపయోగకరంగా ఉంటుంది. కాల్ డేటా అనేది లావాదేవీ యొక్క data పరామితితో పంపబడిన విలువను నిల్వ చేయడానికి ఉపయోగించే బైట్-అడ్రస్ చేయగల రీడ్-ఓన్లీ మెమరీ. calldataని నిర్వహించడానికి EVM నిర్దిష్ట ఆప్‌కోడ్‌లను కలిగి ఉంది. calldatasize డేటా పరిమాణాన్ని అందిస్తుంది. calldataload డేటాను స్టాక్‌లోకి లోడ్ చేస్తుంది. calldatacopy డేటాను మెమరీలోకి కాపీ చేస్తుంది.

ప్రామాణిక వాన్ న్యూమాన్ ఆర్కిటెక్చర్ (opens in a new tab) కోడ్ మరియు డేటాను ఒకే మెమరీలో నిల్వ చేస్తుంది. భద్రతా కారణాల దృష్ట్యా EVM ఈ ప్రమాణాన్ని అనుసరించదు - అస్థిర మెమరీని పంచుకోవడం వల్ల ప్రోగ్రామ్ కోడ్‌ను మార్చడం సాధ్యమవుతుంది. బదులుగా, కోడ్ స్టోరేజ్‌లో సేవ్ చేయబడుతుంది.

మెమరీ నుండి కోడ్ అమలు చేయబడే రెండు సందర్భాలు మాత్రమే ఉన్నాయి:

• ఒక కాంట్రాక్ట్ మరొక కాంట్రాక్ట్‌ను సృష్టించినప్పుడు (CREATE (opens in a new tab) లేదా CREATE2 (opens in a new tab) ఉపయోగించి), కాంట్రాక్ట్ కన్స్ట్రక్టర్ కోసం కోడ్ మెమరీ నుండి వస్తుంది.
• ఏదైనా కాంట్రాక్ట్ సృష్టి సమయంలో, కన్స్ట్రక్టర్ కోడ్ రన్ అవుతుంది మరియు ఆ తర్వాత అసలు కాంట్రాక్ట్ కోడ్‌తో తిరిగి వస్తుంది, ఇది కూడా మెమరీ నుండే వస్తుంది.

అసాధారణ అమలు (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⌉ వ్యక్తీకరణను అర్థం చేసుకోవాలి. బయటి భాగం, ⌈ <value> ⌉ అనేది సీలింగ్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు ఆ విలువ కంటే చిన్నది కాని అతిచిన్న పూర్ణాంకాన్ని అందిస్తుంది. ఉదాహరణకు, ⌈2.5⌉ = ⌈3⌉ = 3. లోపలి భాగం μ_s[2]÷32. పేజీ 3లోని విభాగం 3 (కన్వెన్షన్స్)ని పరిశీలిస్తే, μ అనేది మెషీన్ స్థితి. మెషీన్ స్థితి పేజీ 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⌋ అనేది ఫ్లోర్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు ఆ విలువ కంటే పెద్దది కాని అతిపెద్ద పూర్ణాంకాన్ని అందిస్తుంది. ఉదాహరణకు, ⌊2.5⌋ = ⌊2⌋ = 2. a < √512 అయినప్పుడు, a² < 512, మరియు ఫ్లోర్ ఫంక్షన్ ఫలితం సున్నా అవుతుంది. కాబట్టి మొదటి 22 పదాలకు (704 బైట్లు), అవసరమైన మెమరీ పదాల సంఖ్యతో ఖర్చు సరళంగా పెరుగుతుంది. ఆ పాయింట్ దాటిన తర్వాత ⌊a² ÷ 512⌋ సానుకూలంగా ఉంటుంది. అవసరమైన మెమరీ తగినంత ఎక్కువగా ఉన్నప్పుడు గ్యాస్ ఖర్చు మెమరీ మొత్తానికి వర్గ అనుపాతంలో ఉంటుంది.

గమనిక ఈ కారకాలు స్వాభావిక గ్యాస్ ఖర్చును మాత్రమే ప్రభావితం చేస్తాయి - తుది వినియోగదారు ఎంత చెల్లించాలో నిర్ణయించే ఫీజు మార్కెట్ లేదా వాలిడేటర్లకు ఇచ్చే చిట్కాలను ఇది పరిగణనలోకి తీసుకోదు - ఇది EVMలో ఒక నిర్దిష్ట ఆపరేషన్‌ను అమలు చేయడానికి అయ్యే ముడి ఖర్చు మాత్రమే.

గ్యాస్ గురించి మరింత చదవండి.

9.3 అమలు వాతావరణం

అమలు వాతావరణం అనేది ఒక టపుల్, 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 ఫంక్షన్‌ను నిర్వచిస్తుంది, ఇది మనకు అసాధారణ ముగింపు ఎప్పుడు ఉంటుందో నిర్దేశిస్తుంది. ఇది బూలియన్ (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 స్టాక్ అండర్‌ఫ్లో, ప్రస్తుత ఆప్‌కోడ్ కోసం స్టాక్‌లో తగినన్ని అంశాలు లేవు.

• 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) అయినప్పుడు మాత్రమే జంప్‌లు చెల్లుబాటు అవుతాయి.

• 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] అనేది రిటర్న్ డేటా బఫర్‌లో చదవడానికి ఆఫ్‌సెట్, మరియు స్టాక్ మూలకం μ_s[2] అనేది డేటా పొడవు. మీరు రిటర్న్ డేటా బఫర్ ముగింపుకు మించి చదవడానికి ప్రయత్నించినప్పుడు ఈ పరిస్థితి ఏర్పడుతుంది. కాల్ డేటా లేదా కోడ్ కోసం ఇలాంటి షరతు లేదని గమనించండి. మీరు ఆ బఫర్‌ల ముగింపుకు మించి చదవడానికి ప్రయత్నించినప్పుడు మీకు సున్నాలు మాత్రమే వస్తాయి.

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

  స్టాక్ ఓవర్‌ఫ్లో. ఆప్‌కోడ్‌ను అమలు చేయడం వల్ల 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 మనం స్థిరంగా కాల్ చేయబడితే లాగ్ ఎంట్రీలను విడుదల చేయలేము. లాగ్ ఆప్‌కోడ్‌లన్నీ 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.

ఈ ఫంక్షన్ సమీకరణం (152)లో D_J(c,i) ని నిర్వచించడానికి ఉపయోగించబడుతుంది, ఇది ఆప్‌కోడ్ స్థానం i తో ప్రారంభమయ్యే కోడ్ c లోని అన్ని చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల సెట్ (opens in a new tab). ఈ ఫంక్షన్ పునరావృతంగా నిర్వచించబడింది. i≥||c|| అయితే, మనం కోడ్ ముగింపులో లేదా ఆ తర్వాత ఉన్నామని అర్థం. మనం ఇకపై జంప్ గమ్యస్థానాలను కనుగొనలేము, కాబట్టి ఖాళీ సెట్‌ను తిరిగి ఇవ్వండి.

అన్ని ఇతర సందర్భాల్లో మనం తదుపరి ఆప్‌కోడ్‌కి వెళ్లి దాని నుండి ప్రారంభమయ్యే సెట్‌ను పొందడం ద్వారా మిగిలిన కోడ్‌ను చూస్తాము. c[i] అనేది ప్రస్తుత ఆప్‌కోడ్, కాబట్టి N(i,c[i]) అనేది తదుపరి ఆప్‌కోడ్ యొక్క స్థానం. కాబట్టి D_J(c,N(i,c[i])) అనేది తదుపరి ఆప్‌కోడ్ వద్ద ప్రారంభమయ్యే చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల సెట్. ప్రస్తుత ఆప్‌కోడ్ JUMPDEST కాకపోతే, ఆ సెట్‌ను తిరిగి ఇవ్వండి. అది JUMPDEST అయితే, దానిని ఫలితాల సెట్‌లో చేర్చి దానిని తిరిగి ఇవ్వండి.

9.4.4 సాధారణ నిలుపుదల

నిలుపుదల ఫంక్షన్ H, మూడు రకాల విలువలను తిరిగి ఇవ్వగలదు.

• మనం హాల్ట్ ఆప్‌కోడ్‌లో లేకుంటే, ఖాళీ సెట్ అయిన ∅ ని తిరిగి ఇవ్వండి. సంప్రదాయం ప్రకారం, ఈ విలువ బూలియన్ ఫాల్స్ (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 బిట్స్ మాత్రమే కాబట్టి, మనం మాడ్యులో (opens in a new tab) 2¹⁶⁰ విలువను లెక్కిస్తాము.

σ[μ_s[0] mod 2¹⁶⁰] ≠ ∅ అయితే, ఈ చిరునామా గురించి సమాచారం ఉందని అర్థం. ఆ సందర్భంలో, σ[μ_s[0] mod 2¹⁶⁰]_b అనేది ఆ చిరునామాకు బ్యాలెన్స్. σ[μ_s[0] mod 2¹⁶⁰] = ∅ అయితే, ఈ చిరునామా ప్రారంభించబడలేదని మరియు బ్యాలెన్స్ సున్నా అని అర్థం. మీరు పేజీ 4లోని విభాగం 4.1లో ఖాతా సమాచార ఫీల్డ్‌ల జాబితాను చూడవచ్చు.

రెండవ సమీకరణం, A'_a ≡ A_a ∪ {μ_s[0] mod 2¹⁶⁰}, వార్మ్ స్టోరేజ్ (ఇటీవల యాక్సెస్ చేయబడిన మరియు కాష్ చేయబడే అవకాశం ఉన్న స్టోరేజ్) మరియు కోల్డ్ స్టోరేజ్ (యాక్సెస్ చేయబడని మరియు తిరిగి పొందడానికి ఎక్కువ ఖర్చు అయ్యే నెమ్మదిగా ఉండే స్టోరేజ్‌లో ఉండే అవకాశం ఉన్న స్టోరేజ్) యాక్సెస్ మధ్య ఖర్చు వ్యత్యాసానికి సంబంధించినది. 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 పూర్తిగా నిర్వచించబడింది.

ముగింపు

గణిత సంజ్ఞామానం ఖచ్చితమైనది మరియు ఎథీరియం యొక్క ప్రతి వివరాలను పేర్కొనడానికి ఎల్లో పేపర్‌ను అనుమతించింది. అయితే, దీనికి కొన్ని లోపాలు ఉన్నాయి:

• దీనిని మానవులు మాత్రమే అర్థం చేసుకోగలరు, అంటే సమ్మతి పరీక్షలు (opens in a new tab) మాన్యువల్‌గా వ్రాయబడాలి.
• ప్రోగ్రామర్లు కంప్యూటర్ కోడ్‌ను అర్థం చేసుకుంటారు. వారు గణిత సంజ్ఞామానాన్ని అర్థం చేసుకోవచ్చు లేదా అర్థం చేసుకోకపోవచ్చు.

బహుశా ఈ కారణాల వల్ల, కొత్త ఏకాభిప్రాయ పొర స్పెసిఫికేషన్లు (opens in a new tab) Pythonలో వ్రాయబడ్డాయి. Pythonలో అమలు పొర స్పెసిఫికేషన్లు (opens in a new tab) ఉన్నాయి, కానీ అవి పూర్తి కాలేదు. మొత్తం ఎల్లో పేపర్ కూడా Python లేదా అలాంటి భాషలోకి అనువదించబడే వరకు, ఎల్లో పేపర్ సేవలో కొనసాగుతుంది మరియు దానిని చదవగలగడం సహాయకరంగా ఉంటుంది.