--- title: "ఎల్లో పేపర్ యొక్క EVM స్పెసిఫికేషన్లను అర్థం చేసుకోవడం" description: "ఎథీరియం వర్చువల్ మెషీన్ (EVM) గురించి వివరించే ఎథీరియం యొక్క అధికారిక స్పెసిఫికేషన్లైన ఎల్లో పేపర్ భాగాన్ని అర్థం చేసుకోవడం." author: "qbzzt" tags: ["evm"] skill: intermediate breadcrumb: "ఎల్లో పేపర్ EVM" lang: te published: 2022-05-15 --- [ఎల్లో పేపర్](https://ethereum.github.io/yellowpaper/paper.pdf) అనేది ఎథీరియం యొక్క అధికారిక స్పెసిఫికేషన్. [EIP ప్రక్రియ](/eips/) ద్వారా సవరించబడిన చోట మినహా, ప్రతిదీ ఎలా పనిచేస్తుందో ఖచ్చితమైన వివరణను ఇది కలిగి ఉంటుంది. ఇది గణితశాస్త్ర పత్రంగా వ్రాయబడింది, ఇందులో ప్రోగ్రామర్లకు పరిచయం లేని పదజాలం ఉండవచ్చు. ఈ పత్రంలో మీరు దానిని ఎలా చదవాలో మరియు దాని ద్వారా ఇతర సంబంధిత గణిత పత్రాలను ఎలా చదవాలో నేర్చుకుంటారు. ## ఏ ఎల్లో పేపర్? {#which-yellow-paper} ఎథీరియంలోని దాదాపు ప్రతిదానిలాగే, ఎల్లో పేపర్ కూడా కాలక్రమేణా అభివృద్ధి చెందుతుంది. ఒక నిర్దిష్ట వెర్షన్‌ను సూచించడానికి, నేను [వ్రాసే సమయానికి ఉన్న ప్రస్తుత వెర్షన్‌ను](https://ethereum.github.io/yellowpaper/paper.pdf) అప్‌లోడ్ చేసాను. నేను ఉపయోగించే విభాగం, పేజీ మరియు సమీకరణ సంఖ్యలు ఆ వెర్షన్‌ను సూచిస్తాయి. ఈ పత్రాన్ని చదువుతున్నప్పుడు దానిని వేరే విండోలో తెరిచి ఉంచడం మంచిది. ### EVM ఎందుకు? {#why-the-evm} అసలు ఎల్లో పేపర్ ఎథీరియం అభివృద్ధి ప్రారంభంలోనే వ్రాయబడింది. నెట్‌వర్క్‌ను సురక్షితం చేయడానికి మొదట ఉపయోగించిన అసలు ప్రూఫ్-ఆఫ్-వర్క్ (PoW) ఆధారిత ఏకాభిప్రాయ యంత్రాంగం గురించి ఇది వివరిస్తుంది. అయితే, ఎథీరియం ప్రూఫ్-ఆఫ్-వర్క్ (PoW)ను నిలిపివేసి, సెప్టెంబర్ 2022లో ప్రూఫ్-ఆఫ్-స్టేక్ (PoS) ఆధారిత ఏకాభిప్రాయాన్ని ఉపయోగించడం ప్రారంభించింది. ఈ ట్యుటోరియల్ ఎథీరియం వర్చువల్ మెషీన్‌ను నిర్వచించే ఎల్లో పేపర్ భాగాలపై దృష్టి పెడుతుంది. ప్రూఫ్-ఆఫ్-స్టేక్ (PoS)కి మారడం వల్ల EVM మారలేదు (DIFFICULTY ఆప్‌కోడ్ యొక్క రిటర్న్ విలువ మినహా). ## 9 అమలు నమూనా ఈ విభాగం (పేజీలు 14-16) EVM యొక్క నిర్వచనంలో ఎక్కువ భాగాన్ని కలిగి ఉంటుంది. _సిస్టమ్ స్థితి_ (system state) అనే పదం సిస్టమ్‌ను అమలు చేయడానికి మీరు తెలుసుకోవలసిన ప్రతిదాన్ని కలిగి ఉంటుంది. సాధారణ కంప్యూటర్‌లో, దీని అర్థం మెమరీ, రిజిస్టర్‌ల కంటెంట్ మొదలైనవి. [ట్యూరింగ్ మెషీన్](https://en.wikipedia.org/wiki/Turing_machine) అనేది ఒక గణన నమూనా. ముఖ్యంగా, ఇది కంప్యూటర్ యొక్క సరళీకృత వెర్షన్, ఇది సాధారణ కంప్యూటర్ చేయగల గణనలను అమలు చేయగల సామర్థ్యాన్ని కలిగి ఉందని నిరూపించబడింది (కంప్యూటర్ లెక్కించగల ప్రతిదాన్ని ట్యూరింగ్ మెషీన్ లెక్కించగలదు మరియు దీనికి విరుద్ధంగా కూడా). ఏది లెక్కించదగినది మరియు ఏది కాదు అనే దాని గురించి వివిధ సిద్ధాంతాలను నిరూపించడానికి ఈ నమూనా సులభతరం చేస్తుంది. [ట్యూరింగ్-కంప్లీట్](https://en.wikipedia.org/wiki/Turing_completeness) అనే పదానికి ట్యూరింగ్ మెషీన్ వలె అదే లెక్కలను అమలు చేయగల కంప్యూటర్ అని అర్థం. ట్యూరింగ్ మెషీన్‌లు అనంతమైన లూప్‌లలోకి వెళ్లగలవు, మరియు EVM అలా చేయదు ఎందుకంటే దానికి గ్యాస్ అయిపోతుంది, కాబట్టి ఇది పాక్షిక-ట్యూరింగ్-కంప్లీట్ (quasi-Turing-complete) మాత్రమే. ## 9.1 ప్రాథమిక అంశాలు {#91-basics} ఈ విభాగం EVM యొక్క ప్రాథమికాలను మరియు ఇతర గణన నమూనాలతో ఇది ఎలా పోల్చబడుతుందో తెలియజేస్తుంది. [స్టాక్ మెషీన్](https://en.wikipedia.org/wiki/Stack_machine) అనేది ఇంటర్మీడియట్ డేటాను రిజిస్టర్‌లలో కాకుండా [**స్టాక్**]()లో నిల్వ చేసే కంప్యూటర్. వర్చువల్ మెషీన్‌లకు ఇది ప్రాధాన్యతనిచ్చే ఆర్కిటెక్చర్ ఎందుకంటే దీనిని అమలు చేయడం సులభం, అంటే బగ్‌లు మరియు భద్రతా లోపాలు చాలా తక్కువగా ఉంటాయి. స్టాక్‌లోని మెమరీ 256-బిట్ పదాలుగా విభజించబడింది. కేకాక్-256 హాషింగ్ మరియు దీర్ఘవృత్తాకార వక్రరేఖ గణనల వంటి ఎథీరియం యొక్క ప్రధాన క్రిప్టోగ్రాఫిక్ కార్యకలాపాలకు ఇది సౌకర్యవంతంగా ఉన్నందున ఇది ఎంచుకోబడింది. స్టాక్ యొక్క గరిష్ట పరిమాణం 1024 అంశాలు (1024 x 256 బిట్స్). ఆప్‌కోడ్‌లు అమలు చేయబడినప్పుడు అవి సాధారణంగా స్టాక్ నుండి వాటి పారామితులను పొందుతాయి. స్టాక్‌లోని మూలకాలను పునర్వ్యవస్థీకరించడానికి ప్రత్యేకంగా ఆప్‌కోడ్‌లు ఉన్నాయి, ఉదాహరణకు `POP` (స్టాక్ పైభాగం నుండి అంశాన్ని తీసివేస్తుంది), `DUP_N` (స్టాక్‌లోని Nవ అంశాన్ని నకిలీ చేస్తుంది) మొదలైనవి. EVM అమలు సమయంలో డేటాను నిల్వ చేయడానికి ఉపయోగించే **మెమరీ** అనే అస్థిర స్థలాన్ని కూడా కలిగి ఉంటుంది. ఈ మెమరీ 32-బైట్ పదాలుగా నిర్వహించబడుతుంది. అన్ని మెమరీ స్థానాలు సున్నాకి ప్రారంభించబడతాయి. మెమరీకి ఒక పదాన్ని జోడించడానికి మీరు ఈ [Yul](https://docs.soliditylang.org/en/latest/yul.html) కోడ్‌ను అమలు చేస్తే, అది పదంలోని ఖాళీ స్థలాన్ని సున్నాలతో నింపడం ద్వారా 32 బైట్ల మెమరీని నింపుతుంది, అనగా, ఇది ఒక పదాన్ని సృష్టిస్తుంది - 0-29 స్థానాల్లో సున్నాలతో, 30కి 0x60, మరియు 31కి 0xA7. ```yul mstore(0, 0x60A7) ``` మెమరీతో ఇంటరాక్ట్ అవ్వడానికి EVM అందించే మూడు ఆప్‌కోడ్‌లలో `mstore` ఒకటి - ఇది మెమరీలోకి ఒక పదాన్ని లోడ్ చేస్తుంది. మిగిలిన రెండు `mstore8` ఇది మెమరీలోకి ఒకే బైట్‌ను లోడ్ చేస్తుంది మరియు `mload` ఇది మెమరీ నుండి స్టాక్‌కి ఒక పదాన్ని తరలిస్తుంది. EVM సిస్టమ్ స్థితిలో భాగంగా నిర్వహించబడే ప్రత్యేక నాన్-వొలటైల్ **స్టోరేజ్** నమూనాను కూడా కలిగి ఉంది - ఈ మెమరీ వర్డ్ అర్రేలుగా నిర్వహించబడుతుంది (స్టాక్‌లోని వర్డ్-అడ్రస్ చేయగల బైట్ అర్రేలకు విరుద్ధంగా). ఈ స్టోరేజ్‌లోనే కాంట్రాక్ట్‌లు నిరంతర డేటాను ఉంచుతాయి - ఒక కాంట్రాక్ట్ దాని స్వంత స్టోరేజ్‌తో మాత్రమే ఇంటరాక్ట్ అవుతుంది. స్టోరేజ్ కీ-వాల్యూ మ్యాపింగ్‌లలో నిర్వహించబడుతుంది. ఎల్లో పేపర్‌లోని ఈ విభాగంలో పేర్కొనబడనప్పటికీ, నాల్గవ రకం మెమరీ ఉందని తెలుసుకోవడం కూడా ఉపయోగకరంగా ఉంటుంది. **కాల్ డేటా** అనేది లావాదేవీ యొక్క `data` పరామితితో పంపబడిన విలువను నిల్వ చేయడానికి ఉపయోగించే బైట్-అడ్రస్ చేయగల రీడ్-ఓన్లీ మెమరీ. `calldata`ని నిర్వహించడానికి EVM నిర్దిష్ట ఆప్‌కోడ్‌లను కలిగి ఉంది. `calldatasize` డేటా పరిమాణాన్ని అందిస్తుంది. `calldataload` డేటాను స్టాక్‌లోకి లోడ్ చేస్తుంది. `calldatacopy` డేటాను మెమరీలోకి కాపీ చేస్తుంది. ప్రామాణిక [వాన్ న్యూమాన్ ఆర్కిటెక్చర్](https://en.wikipedia.org/wiki/Von_Neumann_architecture) కోడ్ మరియు డేటాను ఒకే మెమరీలో నిల్వ చేస్తుంది. భద్రతా కారణాల దృష్ట్యా EVM ఈ ప్రమాణాన్ని అనుసరించదు - అస్థిర మెమరీని పంచుకోవడం వల్ల ప్రోగ్రామ్ కోడ్‌ను మార్చడం సాధ్యమవుతుంది. బదులుగా, కోడ్ స్టోరేజ్‌లో సేవ్ చేయబడుతుంది. మెమరీ నుండి కోడ్ అమలు చేయబడే రెండు సందర్భాలు మాత్రమే ఉన్నాయి: - ఒక కాంట్రాక్ట్ మరొక కాంట్రాక్ట్‌ను సృష్టించినప్పుడు ([`CREATE`](https://www.evm.codes/#f0) లేదా [`CREATE2`](https://www.evm.codes/#f5) ఉపయోగించి), కాంట్రాక్ట్ కన్స్ట్రక్టర్ కోసం కోడ్ మెమరీ నుండి వస్తుంది. - _ఏదైనా_ కాంట్రాక్ట్ సృష్టి సమయంలో, కన్స్ట్రక్టర్ కోడ్ రన్ అవుతుంది మరియు ఆ తర్వాత అసలు కాంట్రాక్ట్ కోడ్‌తో తిరిగి వస్తుంది, ఇది కూడా మెమరీ నుండే వస్తుంది. అసాధారణ అమలు (exceptional execution) అనే పదానికి ప్రస్తుత కాంట్రాక్ట్ అమలు నిలిచిపోవడానికి కారణమయ్యే మినహాయింపు అని అర్థం. ## 9.2 ఫీజుల అవలోకనం {#92-fees-overview} గ్యాస్ ఫీజులు ఎలా లెక్కించబడతాయో ఈ విభాగం వివరిస్తుంది. మూడు ఖర్చులు ఉన్నాయి: ### ఆప్‌కోడ్ ఖర్చు నిర్దిష్ట ఆప్‌కోడ్ యొక్క స్వాభావిక ఖర్చు. ఈ విలువను పొందడానికి, అపెండిక్స్ H (పేజీ 29, సమీకరణం (329) కింద)లో ఆప్‌కోడ్ యొక్క ఖర్చు సమూహాన్ని కనుగొనండి మరియు సమీకరణం (326)లో ఖర్చు సమూహాన్ని కనుగొనండి. ఇది మీకు ఖర్చు ఫంక్షన్‌ను ఇస్తుంది, ఇది చాలా సందర్భాలలో అపెండిక్స్ G (పేజీ 28) నుండి పారామితులను ఉపయోగిస్తుంది. ఉదాహరణకు, [`CALLDATACOPY`](https://www.evm.codes/#37) ఆప్‌కోడ్ _Wcopy_ సమూహంలో సభ్యుడు. ఆ సమూహానికి ఆప్‌కోడ్ ఖర్చు _Gverylow+Gcopy×⌈μs[2]÷32⌉_. అపెండిక్స్ Gని పరిశీలిస్తే, రెండు స్థిరాంకాలు 3 అని మనం చూస్తాము, ఇది మనకు _3+3×⌈μs[2]÷32⌉_ ఇస్తుంది. మనం ఇంకా _⌈μs[2]÷32⌉_ వ్యక్తీకరణను అర్థం చేసుకోవాలి. బయటి భాగం, _⌈ \ ⌉_ అనేది సీలింగ్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు ఆ విలువ కంటే తక్కువ కాని అతిచిన్న పూర్ణాంకాన్ని తిరిగి ఇస్తుంది. ఉదాహరణకు, _⌈2.5⌉ = ⌈3⌉ = 3_. లోపలి భాగం _μs[2]÷32_. పేజీ 3లోని విభాగం 3 (సంప్రదాయాలు)ని పరిశీలిస్తే, _μ_ అనేది మెషీన్ స్థితి. మెషీన్ స్థితి పేజీ 15లోని విభాగం 9.4.1లో నిర్వచించబడింది. ఆ విభాగం ప్రకారం, మెషీన్ స్థితి పారామితులలో ఒకటి స్టాక్ కోసం _s_. వీటన్నింటినీ కలిపి చూస్తే, _μs[2]_ అనేది స్టాక్‌లోని స్థానం #2 అని తెలుస్తోంది. [ఆప్‌కోడ్](https://www.evm.codes/#37)ని పరిశీలిస్తే, స్టాక్‌లోని స్థానం #2 అనేది బైట్‌లలో డేటా పరిమాణం. Wcopy సమూహంలోని ఇతర ఆప్‌కోడ్‌లను పరిశీలిస్తే, [`CODECOPY`](https://www.evm.codes/#39) మరియు [`RETURNDATACOPY`](https://www.evm.codes/#3e), అవి కూడా అదే స్థానంలో డేటా పరిమాణాన్ని కలిగి ఉంటాయి. కాబట్టి _⌈μs[2]÷32⌉_ అనేది కాపీ చేయబడుతున్న డేటాను నిల్వ చేయడానికి అవసరమైన 32 బైట్ పదాల సంఖ్య. వీటన్నింటినీ కలిపి చూస్తే, [`CALLDATACOPY`](https://www.evm.codes/#37) యొక్క స్వాభావిక ఖర్చు 3 గ్యాస్ ప్లస్ కాపీ చేయబడుతున్న డేటాలోని ప్రతి పదానికి 3. ### రన్నింగ్ ఖర్చు {#running-cost} మనం కాల్ చేస్తున్న కోడ్‌ను అమలు చేయడానికి అయ్యే ఖర్చు. - [`CREATE`](https://www.evm.codes/#f0) మరియు [`CREATE2`](https://www.evm.codes/#f5) విషయంలో, కొత్త కాంట్రాక్ట్ కోసం కన్స్ట్రక్టర్. - [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa), లేదా [`DELEGATECALL`](https://www.evm.codes/#f4) విషయంలో, మనం కాల్ చేసే కాంట్రాక్ట్. ### మెమరీని విస్తరించే ఖర్చు మెమరీని విస్తరించడానికి అయ్యే ఖర్చు (అవసరమైతే). సమీకరణం 326లో, ఈ విలువ _Cmem(μi')-Cmem(μi)_ గా వ్రాయబడింది. మళ్లీ విభాగం 9.4.1ని పరిశీలిస్తే, _μi_ అనేది మెమరీలోని పదాల సంఖ్య అని మనం చూస్తాము. కాబట్టి _μi_ అనేది ఆప్‌కోడ్‌కు ముందు మెమరీలోని పదాల సంఖ్య మరియు _μi'_ అనేది ఆప్‌కోడ్ తర్వాత మెమరీలోని పదాల సంఖ్య. _Cmem_ ఫంక్షన్ సమీకరణం 328లో నిర్వచించబడింది: _Cmem(a) = Gmemory × a + ⌊a2 ÷ 512⌋_. _⌊x⌋_ అనేది ఫ్లోర్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు ఆ విలువ కంటే పెద్దది కాని అతిపెద్ద పూర్ణాంకాన్ని తిరిగి ఇస్తుంది. ఉదాహరణకు, _⌊2.5⌋ = ⌊2⌋ = 2._ _a < √512_ అయినప్పుడు, _a2 < 512_, మరియు ఫ్లోర్ ఫంక్షన్ ఫలితం సున్నా అవుతుంది. కాబట్టి మొదటి 22 పదాలకు (704 బైట్‌లు), అవసరమైన మెమరీ పదాల సంఖ్యతో ఖర్చు సరళంగా పెరుగుతుంది. ఆ పాయింట్ దాటిన తర్వాత _⌊a2 ÷ 512⌋_ సానుకూలంగా ఉంటుంది. అవసరమైన మెమరీ తగినంత ఎక్కువగా ఉన్నప్పుడు గ్యాస్ ఖర్చు మెమరీ పరిమాణం యొక్క వర్గానికి అనులోమానుపాతంలో ఉంటుంది. **గమనిక** ఈ కారకాలు _స్వాభావిక_ గ్యాస్ ఖర్చును మాత్రమే ప్రభావితం చేస్తాయి - తుది వినియోగదారు ఎంత చెల్లించాలో నిర్ణయించే ఫీజు మార్కెట్ లేదా వాలిడేటర్‌లకు ఇచ్చే చిట్కాలను ఇది పరిగణనలోకి తీసుకోదు - ఇది EVMలో ఒక నిర్దిష్ట ఆపరేషన్‌ను అమలు చేయడానికి అయ్యే ముడి ఖర్చు మాత్రమే. [గ్యాస్ గురించి మరింత చదవండి](/developers/docs/gas/). ## 9.3 అమలు పర్యావరణం అమలు పర్యావరణం అనేది ఒక టపుల్, _I_, ఇది బ్లాక్‌చైన్ స్థితి లేదా EVMలో భాగం కాని సమాచారాన్ని కలిగి ఉంటుంది. | పరామితి | డేటాను యాక్సెస్ చేయడానికి ఆప్‌కోడ్ | డేటాను యాక్సెస్ చేయడానికి Solidity కోడ్ | | --------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | | _Ia_ | [`ADDRESS`](https://www.evm.codes/#30) | `address(this)` | | _Io_ | [`ORIGIN`](https://www.evm.codes/#32) | `tx.origin` | | _Ip_ | [`GASPRICE`](https://www.evm.codes/#3a) | `tx.gasprice` | | _Id_ | [`CALLDATALOAD`](https://www.evm.codes/#35), మొదలైనవి. | `msg.data` | | _Is_ | [`CALLER`](https://www.evm.codes/#33) | `msg.sender` | | _Iv_ | [`CALLVALUE`](https://www.evm.codes/#34) | `msg.value` | | _Ib_ | [`CODECOPY`](https://www.evm.codes/#39) | `address(this).code` | | _IH_ | బ్లాక్ శీర్షిక ఫీల్డ్‌లు, ఉదాహరణకు [`NUMBER`](https://www.evm.codes/#43) మరియు [`DIFFICULTY`](https://www.evm.codes/#44) | `block.number`, `block.difficulty`, మొదలైనవి. | | _Ie_ | కాంట్రాక్ట్‌ల మధ్య కాల్‌ల కోసం కాల్ స్టాక్ యొక్క లోతు (కాంట్రాక్ట్ సృష్టితో సహా) | | _Iw_ | EVM స్థితిని మార్చడానికి అనుమతించబడిందా, లేదా అది స్థిరంగా నడుస్తుందా | విభాగం 9లోని మిగిలిన భాగాన్ని అర్థం చేసుకోవడానికి మరికొన్ని పారామితులు అవసరం: | పరామితి | విభాగంలో నిర్వచించబడింది | అర్థం | | --------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | _σ_ | 2 (పేజీ 2, సమీకరణం 1) | బ్లాక్‌చైన్ యొక్క స్థితి | | _g_ | 9.3 (పేజీ 14) | మిగిలిన గ్యాస్ | | _A_ | 6.1 (పేజీ 9) | సేకరించబడిన ఉపస్థితి (లావాదేవీ ముగిసినప్పుడు షెడ్యూల్ చేయబడిన మార్పులు) | | _o_ | 9.3 (పేజీ 14) | అవుట్‌పుట్ - అంతర్గత లావాదేవీ విషయంలో (ఒక కాంట్రాక్ట్ మరొకదానిని కాల్ చేసినప్పుడు) మరియు వ్యూ ఫంక్షన్‌లకు కాల్ చేసినప్పుడు (మీరు కేవలం సమాచారం కోసం అడుగుతున్నప్పుడు, కాబట్టి లావాదేవీ కోసం వేచి ఉండాల్సిన అవసరం లేదు) తిరిగి వచ్చిన ఫలితం | ## 9.4 అమలు అవలోకనం ఇప్పుడు మనకు అన్ని ప్రాథమిక అంశాలు ఉన్నాయి కాబట్టి, EVM ఎలా పనిచేస్తుందో మనం చివరకు పని చేయడం ప్రారంభించవచ్చు. సమీకరణాలు 146-151 EVMను అమలు చేయడానికి ప్రారంభ పరిస్థితులను ఇస్తాయి: | చిహ్నం | ప్రారంభ విలువ | అర్థం | | ---------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | _μg_ | _g_ | మిగిలిన గ్యాస్ | | _μpc_ | _0_ | ప్రోగ్రామ్ కౌంటర్, అమలు చేయాల్సిన తదుపరి సూచన యొక్క చిరునామా | | _μm_ | _(0, 0, ...)_ | మెమరీ, అన్నీ సున్నాలకు ప్రారంభించబడింది | | _μi_ | _0_ | ఉపయోగించిన అత్యధిక మెమరీ స్థానం | | _μs_ | _()_ | స్టాక్, ప్రారంభంలో ఖాళీగా ఉంటుంది | | _μo_ | _∅_ | అవుట్‌పుట్, మనం రిటర్న్ డేటాతో ([`RETURN`](https://www.evm.codes/#f3) లేదా [`REVERT`](https://www.evm.codes/#fd)) లేదా అది లేకుండా ([`STOP`](https://www.evm.codes/#00) లేదా [`SELFDESTRUCT`](https://www.evm.codes/#ff)) ఆగిపోయే వరకు ఖాళీ సెట్. | అమలు సమయంలో ప్రతి పాయింట్ వద్ద నాలుగు సాధ్యమైన పరిస్థితులు ఉన్నాయని మరియు వాటితో ఏమి చేయాలో సమీకరణం 152 చెబుతుంది: 1. `Z(σ,μ,A,I)`. Z అనేది ఒక ఆపరేషన్ చెల్లని స్థితి పరివర్తనను సృష్టిస్తుందో లేదో పరీక్షించే ఫంక్షన్‌ను సూచిస్తుంది ([అసాధారణ నిలుపుదల](#942-exceptional-halt) చూడండి). ఇది ట్రూ (True)గా మూల్యాంకనం చేయబడితే, కొత్త స్థితి పాతదానితో సమానంగా ఉంటుంది (గ్యాస్ కాలిపోవడం మినహా) ఎందుకంటే మార్పులు అమలు చేయబడలేదు. 2. అమలు చేయబడుతున్న ఆప్‌కోడ్ [`REVERT`](https://www.evm.codes/#fd) అయితే, కొత్త స్థితి పాత స్థితికి సమానంగా ఉంటుంది, కొంత గ్యాస్ పోతుంది. 3. ఆపరేషన్ల క్రమం పూర్తయితే, [`RETURN`](https://www.evm.codes/#f3) ద్వారా సూచించబడినట్లుగా, స్థితి కొత్త స్థితికి నవీకరించబడుతుంది. 4. మనం 1-3 ముగింపు పరిస్థితులలో ఒకదానిలో లేకుంటే, అమలు చేయడం కొనసాగించండి. ## 9.4.1 మెషీన్ స్థితి {#941-machine-state} ఈ విభాగం మెషీన్ స్థితిని మరింత వివరంగా వివరిస్తుంది. ఇది _w_ అనేది ప్రస్తుత ఆప్‌కోడ్ అని నిర్దేశిస్తుంది. _μpc_ అనేది కోడ్ పొడవు _||Ib||_ కంటే తక్కువగా ఉంటే, ఆ బైట్ (_Ib[μpc]_) ఆప్‌కోడ్ అవుతుంది. లేకపోతే, ఆప్‌కోడ్ [`STOP`](https://www.evm.codes/#00)గా నిర్వచించబడుతుంది. ఇది [స్టాక్ మెషీన్](https://en.wikipedia.org/wiki/Stack_machine) కాబట్టి, ప్రతి ఆప్‌కోడ్ ద్వారా పాప్ చేయబడిన (_δ_) మరియు పుష్ చేయబడిన (_α_) అంశాల సంఖ్యను మనం ట్రాక్ చేయాలి. ## 9.4.2 అసాధారణ నిలుపుదల ఈ విభాగం _Z_ ఫంక్షన్‌ను నిర్వచిస్తుంది, ఇది మనకు అసాధారణ ముగింపు ఎప్పుడు ఉంటుందో నిర్దేశిస్తుంది. ఇది ఒక [బూలియన్](https://en.wikipedia.org/wiki/Boolean_data_type) ఫంక్షన్, కాబట్టి ఇది [లాజికల్ ఆర్ (or) కోసం _∨_](https://en.wikipedia.org/wiki/Logical_disjunction) మరియు [లాజికల్ అండ్ (and) కోసం _∧_](https://en.wikipedia.org/wiki/Logical_conjunction) ఉపయోగిస్తుంది. ఈ షరతులలో ఏవైనా నిజమైతే మనకు అసాధారణ నిలుపుదల ఉంటుంది: - **_μg < C(σ,μ,A,I)_** విభాగం 9.2లో మనం చూసినట్లుగా, _C_ అనేది గ్యాస్ ఖర్చును నిర్దేశించే ఫంక్షన్. తదుపరి ఆప్‌కోడ్‌ను కవర్ చేయడానికి తగినంత గ్యాస్ మిగిలి లేదు. - **_δw=∅_** ఒక ఆప్‌కోడ్ కోసం పాప్ చేయబడిన అంశాల సంఖ్య నిర్వచించబడకపోతే, ఆప్‌కోడ్ కూడా నిర్వచించబడదు. - **_|| μs || < δw_** స్టాక్ అండర్‌ఫ్లో, ప్రస్తుత ఆప్‌కోడ్ కోసం స్టాక్‌లో తగినంత అంశాలు లేవు. - **_w = JUMP ∧ μs[0]∉D(Ib)_** ఆప్‌కోడ్ [`JUMP`](https://www.evm.codes/#56) మరియు చిరునామా [`JUMPDEST`](https://www.evm.codes/#5b) కాదు. గమ్యస్థానం [`JUMPDEST`](https://www.evm.codes/#5b) అయినప్పుడు _మాత్రమే_ జంప్‌లు చెల్లుబాటు అవుతాయి. - **_w = JUMPI ∧ μs[1]≠0 ∧ μs[0] ∉ D(Ib)_** ఆప్‌కోడ్ [`JUMPI`](https://www.evm.codes/#57), షరతు నిజం (సున్నా కాదు) కాబట్టి జంప్ జరగాలి, మరియు చిరునామా [`JUMPDEST`](https://www.evm.codes/#5b) కాదు. గమ్యస్థానం [`JUMPDEST`](https://www.evm.codes/#5b) అయినప్పుడు _మాత్రమే_ జంప్‌లు చెల్లుబాటు అవుతాయి. - **_w = RETURNDATACOPY ∧ μs[1]+μs[2]>|| μo ||_** ఆప్‌కోడ్ [`RETURNDATACOPY`](https://www.evm.codes/#3e). ఈ ఆప్‌కోడ్‌లో స్టాక్ మూలకం _μs[1]_ అనేది రిటర్న్ డేటా బఫర్ నుండి చదవడానికి ఆఫ్‌సెట్, మరియు స్టాక్ మూలకం _μs[2]_ అనేది డేటా పొడవు. రిటర్న్ డేటా బఫర్ ముగింపుకు మించి చదవడానికి మీరు ప్రయత్నించినప్పుడు ఈ పరిస్థితి ఏర్పడుతుంది. కాల్ డేటా లేదా కోడ్ కోసం ఇలాంటి షరతు లేదని గమనించండి. ఆ బఫర్‌ల ముగింపుకు మించి చదవడానికి మీరు ప్రయత్నించినప్పుడు మీకు సున్నాలు మాత్రమే వస్తాయి. - **_|| μs || - δw + αw > 1024_** స్టాక్ ఓవర్‌ఫ్లో. ఆప్‌కోడ్‌ను అమలు చేయడం వల్ల 1024 కంటే ఎక్కువ అంశాల స్టాక్ ఏర్పడితే, నిలిపివేయండి. - **_¬Iw ∧ W(w,μ)_** మనం స్థిరంగా నడుస్తున్నామా ([¬ అనేది నెగేషన్](https://en.wikipedia.org/wiki/Negation) మరియు బ్లాక్‌చైన్ స్థితిని మార్చడానికి మనకు అనుమతి ఉన్నప్పుడు _Iw_ నిజం)? అలా అయితే, మరియు మనం స్థితిని మార్చే ఆపరేషన్‌ను ప్రయత్నిస్తుంటే, అది జరగదు. _W(w,μ)_ ఫంక్షన్ తర్వాత సమీకరణం 159లో నిర్వచించబడింది. ఈ షరతులలో ఒకటి నిజమైతే _W(w,μ)_ నిజం: - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_** ఈ ఆప్‌కోడ్‌లు కొత్త కాంట్రాక్ట్‌ను సృష్టించడం ద్వారా, విలువను నిల్వ చేయడం ద్వారా లేదా ప్రస్తుత కాంట్రాక్ట్‌ను నాశనం చేయడం ద్వారా స్థితిని మారుస్తాయి. - **_LOG0≤w ∧ w≤LOG4_** మనం స్థిరంగా కాల్ చేయబడితే లాగ్ ఎంట్రీలను విడుదల చేయలేము. లాగ్ ఆప్‌కోడ్‌లన్నీ [`LOG0` (A0)](https://www.evm.codes/#a0) మరియు [`LOG4` (A4)](https://www.evm.codes/#a4) మధ్య పరిధిలో ఉంటాయి. లాగ్ ఆప్‌కోడ్ తర్వాత ఉన్న సంఖ్య లాగ్ ఎంట్రీలో ఎన్ని అంశాలు ఉన్నాయో నిర్దేశిస్తుంది. - **_w=CALL ∧ μs[2]≠0_** మీరు స్థిరంగా ఉన్నప్పుడు మరొక కాంట్రాక్ట్‌ను కాల్ చేయవచ్చు, కానీ మీరు అలా చేస్తే దానికి ETHని బదిలీ చేయలేరు. - **_w = SSTORE ∧ μg ≤ Gcallstipend_** మీకు Gcallstipend (అపెండిక్స్ Gలో 2300గా నిర్వచించబడింది) గ్యాస్ కంటే ఎక్కువ ఉంటే తప్ప మీరు [`SSTORE`](https://www.evm.codes/#55)ని అమలు చేయలేరు. ## 9.4.3 జంప్ గమ్యస్థాన చెల్లుబాటు ఇక్కడ మనం [`JUMPDEST`](https://www.evm.codes/#5b) ఆప్‌కోడ్‌లు అంటే ఏమిటో అధికారికంగా నిర్వచిస్తాము. మనం కేవలం బైట్ విలువ 0x5B కోసం వెతకలేము, ఎందుకంటే అది PUSH లోపల ఉండవచ్చు (అందువల్ల అది డేటా అవుతుంది మరియు ఆప్‌కోడ్ కాదు). సమీకరణం (162)లో మనం _N(i,w)_ అనే ఫంక్షన్‌ను నిర్వచిస్తాము. మొదటి పరామితి, _i_, ఆప్‌కోడ్ యొక్క స్థానం. రెండవది, _w_, ఆప్‌కోడ్. _w∈[PUSH1, PUSH32]_ అయితే ఆ ఆప్‌కోడ్ ఒక PUSH అని అర్థం (చదరపు బ్రాకెట్‌లు ముగింపు బిందువులను కలిగి ఉన్న పరిధిని నిర్వచిస్తాయి). ఆ సందర్భంలో తదుపరి ఆప్‌కోడ్ _i+2+(w−PUSH1)_ వద్ద ఉంటుంది. [`PUSH1`](https://www.evm.codes/#60) కోసం మనం రెండు బైట్‌లు ముందుకు వెళ్లాలి (PUSH మరియు ఒక బైట్ విలువ), [`PUSH2`](https://www.evm.codes/#61) కోసం మనం మూడు బైట్‌లు ముందుకు వెళ్లాలి ఎందుకంటే ఇది రెండు బైట్‌ల విలువ, మొదలైనవి. అన్ని ఇతర EVM ఆప్‌కోడ్‌లు కేవలం ఒక బైట్ పొడవు మాత్రమే ఉంటాయి, కాబట్టి అన్ని ఇతర సందర్భాల్లో _N(i,w)=i+1_. ఈ ఫంక్షన్ సమీకరణం (161)లో _DJ(c,i)_ ని నిర్వచించడానికి ఉపయోగించబడుతుంది, ఇది ఆప్‌కోడ్ స్థానం _i_ తో ప్రారంభమయ్యే కోడ్ _c_ లోని అన్ని చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల [సమితి](). ఈ ఫంక్షన్ పునరావృతంగా నిర్వచించబడింది. _i≥||c||_ అయితే, మనం కోడ్ ముగింపులో లేదా ఆ తర్వాత ఉన్నామని అర్థం. మనం ఇకపై ఎలాంటి జంప్ గమ్యస్థానాలను కనుగొనలేము, కాబట్టి ఖాళీ సమితిని తిరిగి ఇవ్వండి. అన్ని ఇతర సందర్భాల్లో మనం తదుపరి ఆప్‌కోడ్‌కి వెళ్లి, దాని నుండి ప్రారంభమయ్యే సమితిని పొందడం ద్వారా మిగిలిన కోడ్‌ను చూస్తాము. _c[i]_ అనేది ప్రస్తుత ఆప్‌కోడ్, కాబట్టి _N(i,c[i])_ అనేది తదుపరి ఆప్‌కోడ్ యొక్క స్థానం. అందువల్ల _DJ(c,N(i,c[i]))_ అనేది తదుపరి ఆప్‌కోడ్ వద్ద ప్రారంభమయ్యే చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల సమితి. ప్రస్తుత ఆప్‌కోడ్ `JUMPDEST` కాకపోతే, ఆ సమితిని తిరిగి ఇవ్వండి. అది `JUMPDEST` అయితే, దానిని ఫలిత సమితిలో చేర్చి, దానిని తిరిగి ఇవ్వండి. ## 9.4.4 సాధారణ నిలుపుదల {#944-normal-halt} నిలుపుదల ఫంక్షన్ _H_, మూడు రకాల విలువలను తిరిగి ఇవ్వగలదు. - మనం హాల్ట్ ఆప్‌కోడ్‌లో లేకుంటే, ఖాళీ సెట్ అయిన _∅_ ని తిరిగి ఇవ్వండి. సంప్రదాయం ప్రకారం, ఈ విలువ బూలియన్ ఫాల్స్ (false)గా అన్వయించబడుతుంది. - మనకు అవుట్‌పుట్‌ను ఉత్పత్తి చేయని హాల్ట్ ఆప్‌కోడ్ ఉంటే ([`STOP`](https://www.evm.codes/#00) లేదా [`SELFDESTRUCT`](https://www.evm.codes/#ff)), రిటర్న్ విలువగా సున్నా బైట్ల పరిమాణం గల క్రమాన్ని తిరిగి ఇవ్వండి. ఇది ఖాళీ సెట్ నుండి చాలా భిన్నంగా ఉంటుందని గమనించండి. ఈ విలువ అంటే EVM నిజంగా నిలిచిపోయిందని, చదవడానికి రిటర్న్ డేటా ఏమీ లేదని అర్థం. - మనకు అవుట్‌పుట్‌ను ఉత్పత్తి చేసే హాల్ట్ ఆప్‌కోడ్ ఉంటే ([`RETURN`](https://www.evm.codes/#f3) లేదా [`REVERT`](https://www.evm.codes/#fd)), ఆ ఆప్‌కోడ్ ద్వారా పేర్కొనబడిన బైట్ల క్రమాన్ని తిరిగి ఇవ్వండి. ఈ క్రమం మెమరీ నుండి తీసుకోబడింది, స్టాక్ పైభాగంలో ఉన్న విలువ (_μs[0]_) మొదటి బైట్, మరియు దాని తర్వాత ఉన్న విలువ (_μs[1]_) పొడవు. ## H.2 సూచనల సమితి మనం EVM యొక్క చివరి ఉపవిభాగం 9.5కి వెళ్లే ముందు, సూచనలను చూద్దాం. అవి పేజీ 30లో ప్రారంభమయ్యే అనుబంధం H.2లో నిర్వచించబడ్డాయి. ఆ నిర్దిష్ట ఆప్‌కోడ్‌తో మారుతున్నట్లు పేర్కొనబడని ఏదైనా అలాగే ఉంటుందని ఆశించబడుతుంది. మారే వేరియబుల్స్ \′ గా పేర్కొనబడతాయి. ఉదాహరణకు, [`ADD`](https://www.evm.codes/#01) ఆప్‌కోడ్‌ను చూద్దాం. | విలువ | నెమోనిక్ | δ | α | వివరణ | | ----: | -------- | --- | --- | --------------------------------------------------------- | | 0x01 | ADD | 2 | 1 | కూడిక ఆపరేషన్. | | | | | | _μ′s[0] ≡ μs[0] + μs[1]_ | _δ_ అనేది మనం స్టాక్ నుండి పాప్ చేసే విలువల సంఖ్య. ఈ సందర్భంలో రెండు, ఎందుకంటే మనం పై రెండు విలువలను కలుపుతున్నాము. _α_ అనేది మనం తిరిగి పుష్ చేసే విలువల సంఖ్య. ఈ సందర్భంలో ఒకటి, మొత్తం. కాబట్టి కొత్త స్టాక్ పైభాగం (_μ′s[0]_) అనేది పాత స్టాక్ పైభాగం (_μs[0]_) మరియు దాని క్రింద ఉన్న పాత విలువ (_μs[1]_) యొక్క మొత్తం. అన్ని ఆప్‌కోడ్‌లను విసుగు పుట్టించే సుదీర్ఘ జాబితాతో పరిశీలించే బదులు, ఈ కథనం కొత్తగా ఏదైనా పరిచయం చేసే ఆప్‌కోడ్‌లను మాత్రమే వివరిస్తుంది. | విలువ | నెమోనిక్ | δ | α | వివరణ | | ----: | --------- | --- | --- | ---------------------------------------------------------------------------------------------------------- | | 0x20 | KECCAK256 | 2 | 1 | కేకాక్-256 హాష్‌ను లెక్కించండి. | | | | | | _μ′s[0] ≡ KEC(μm[μs[0] . . . (μs[0] + μs[1] − 1)])_ | | | | | | _μ′i ≡ M(μi,μs[0],μs[1])_ | మెమరీని యాక్సెస్ చేసే మొదటి ఆప్‌కోడ్ ఇది (ఈ సందర్భంలో, చదవడానికి మాత్రమే). అయితే, ఇది మెమరీ యొక్క ప్రస్తుత పరిమితులకు మించి విస్తరించవచ్చు, కాబట్టి మనం _μi_ ని అప్‌డేట్ చేయాలి. పేజీ 30లోని సమీకరణం 330లో నిర్వచించబడిన _M_ ఫంక్షన్‌ని ఉపయోగించి మనం దీన్ని చేస్తాము. | విలువ | నెమోనిక్ | δ | α | వివరణ | | ----: | -------- | --- | --- | --------------------------------- | | 0x31 | BALANCE | 1 | 1 | ఇచ్చిన ఖాతా బ్యాలెన్స్‌ను పొందండి. | | | | | | ... | మనం బ్యాలెన్స్ కనుగొనాల్సిన చిరునామా _μs[0] mod 2160_. స్టాక్ పైభాగం చిరునామా, కానీ చిరునామాలు కేవలం 160 బిట్‌లు మాత్రమే కాబట్టి, మనం విలువను 2160 [మాడ్యులో](https://en.wikipedia.org/wiki/Modulo_operation) ద్వారా లెక్కిస్తాము. _σ[μs[0] mod 2160] ≠ ∅_ అయితే, ఈ చిరునామా గురించి సమాచారం ఉందని అర్థం. ఆ సందర్భంలో, _σ[μs[0] mod 2160]b_ అనేది ఆ చిరునామా యొక్క బ్యాలెన్స్. _σ[μs[0] mod 2160] = ∅_ అయితే, ఈ చిరునామా ప్రారంభించబడలేదని మరియు బ్యాలెన్స్ సున్నా అని అర్థం. మీరు పేజీ 4లోని విభాగం 4.1లో ఖాతా సమాచార ఫీల్డ్‌ల జాబితాను చూడవచ్చు. రెండవ సమీకరణం, _A'a ≡ Aa ∪ \{μs[0] mod 2160\}_, వార్మ్ స్టోరేజ్ (ఇటీవల యాక్సెస్ చేయబడిన మరియు కాష్ చేయబడే అవకాశం ఉన్న స్టోరేజ్) మరియు కోల్డ్ స్టోరేజ్ (యాక్సెస్ చేయబడని మరియు తిరిగి పొందడానికి ఎక్కువ ఖర్చు అయ్యే నెమ్మదిగా ఉండే స్టోరేజ్‌లో ఉండే అవకాశం ఉన్న స్టోరేజ్) యాక్సెస్ మధ్య ఖర్చు వ్యత్యాసానికి సంబంధించినది. _Aa_ అనేది లావాదేవీ ద్వారా గతంలో యాక్సెస్ చేయబడిన చిరునామాల జాబితా, కాబట్టి పేజీ 9లోని విభాగం 6.1లో నిర్వచించినట్లుగా, వీటిని యాక్సెస్ చేయడం చౌకగా ఉండాలి. మీరు ఈ విషయం గురించి [EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)లో మరింత చదవవచ్చు. | విలువ | నెమోనిక్ | δ | α | వివరణ | | ----: | -------- | --- | --- | --------------------------------------- | | 0x8F | DUP16 | 16 | 17 | 16వ స్టాక్ అంశాన్ని నకిలీ చేయండి. | | | | | | _μ′s[0] ≡ μs[15]_ | ఏదైనా స్టాక్ అంశాన్ని ఉపయోగించడానికి, మనం దానిని పాప్ చేయాలి, అంటే దాని పైన ఉన్న అన్ని స్టాక్ అంశాలను కూడా మనం పాప్ చేయాలి. [`DUP`](https://www.evm.codes/#8f) మరియు [`SWAP`](https://www.evm.codes/#9f) విషయంలో, దీని అర్థం పదహారు విలువల వరకు పాప్ చేసి, ఆపై పుష్ చేయాల్సి ఉంటుంది. ## 9.5 అమలు చక్రం ఇప్పుడు మనకు అన్ని భాగాలు ఉన్నందున, EVM యొక్క అమలు చక్రం ఎలా డాక్యుమెంట్ చేయబడిందో మనం చివరకు అర్థం చేసుకోవచ్చు. సమీకరణం (164) ఈ స్థితిని బట్టి ఇలా చెబుతుంది: - _σ_ (గ్లోబల్ బ్లాక్‌చైన్ స్థితి) - _μ_ (EVM స్థితి) - _A_ (ఉపస్థితి, లావాదేవీ ముగిసినప్పుడు జరగాల్సిన మార్పులు) - _I_ (అమలు వాతావరణం) కొత్త స్థితి _(σ', μ', A', I')_. సమీకరణాలు (165)-(167) స్టాక్‌ను మరియు ఆప్‌కోడ్ (_μs_) కారణంగా దానిలో మార్పును నిర్వచిస్తాయి. సమీకరణం (168) అనేది గ్యాస్‌లో మార్పు (_μg_). సమీకరణం (169) అనేది ప్రోగ్రామ్ కౌంటర్‌లో మార్పు (_μpc_). చివరగా, సమీకరణాలు (170)-(173) ఆప్‌కోడ్ ద్వారా స్పష్టంగా మార్చబడితే తప్ప, ఇతర పారామితులు అలాగే ఉంటాయని నిర్దేశిస్తాయి. దీనితో EVM పూర్తిగా నిర్వచించబడింది. ## ముగింపు {#conclusion} గణిత సంజ్ఞామానం ఖచ్చితమైనది మరియు ఎథీరియం యొక్క ప్రతి వివరాలను పేర్కొనడానికి ఎల్లో పేపర్‌ను అనుమతించింది. అయితే, దీనికి కొన్ని లోపాలు ఉన్నాయి: - దీనిని మానవులు మాత్రమే అర్థం చేసుకోగలరు, అంటే [సమ్మతి పరీక్షలు](https://github.com/ethereum/tests) మాన్యువల్‌గా వ్రాయబడాలి. - ప్రోగ్రామర్లు కంప్యూటర్ కోడ్‌ను అర్థం చేసుకుంటారు. వారు గణిత సంజ్ఞామానాన్ని అర్థం చేసుకోవచ్చు లేదా అర్థం చేసుకోకపోవచ్చు. బహుశా ఈ కారణాల వల్ల, కొత్త [ఏకాభిప్రాయ పొర స్పెసిఫికేషన్లు](https://github.com/ethereum/consensus-specs/blob/master/tests/core/pyspec/README.md) Pythonలో వ్రాయబడ్డాయి. [Pythonలో అమలు పొర స్పెసిఫికేషన్లు](https://ethereum.github.io/execution-specs) ఉన్నాయి, కానీ అవి పూర్తి కాలేదు. మొత్తం ఎల్లో పేపర్ కూడా Python లేదా అలాంటి భాషలోకి అనువదించబడే వరకు, ఎల్లో పేపర్ సేవలో కొనసాగుతుంది మరియు దానిని చదవగలగడం సహాయకరంగా ఉంటుంది.