ప్రధాన కంటెంట్‌కు దాటవేయి
Change page

ఎథాష్

పేజీ చివరి నవీకరణ: 15 ఏప్రిల్, 2026

ఈతాష్ అనేది ఇథిరియం యొక్క ప్రూఫ్-ఆఫ్-వర్క్ మైనింగ్ అల్గారిథంగా ఉండేది. ప్రూఫ్-ఆఫ్-వర్క్ ఇప్పుడు పూర్తిగా స్విచ్ ఆఫ్ చేయబడింది మరియు ఇతీరియము ఇప్పుడు దానికి బదులుగా ప్రూఫ్-ఆఫ్-స్టేక్ ఉపయోగించి సురక్షితం చేయబడింది. ది మెర్జ్, ప్రూఫ్-ఆఫ్-స్టేక్ మరియు స్టేకింగ్ గురించి మరింత చదవండి. ఈ పేజీ చారిత్రక ఆసక్తి కోసం మాత్రమే!

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

ఈతాష్ ఎలా పని చేస్తుంది?

నాన్స్ మరియు బ్లాక్ హెడర్‌పై ఆధారపడిన స్థిరమైన వనరు యొక్క ఉపసమితులను ఎంచుకోవాల్సిన ప్రూఫ్ ఆఫ్ వర్క్ అల్గారిథంతో మెమరీ కాఠిన్యం సాధించబడుతుంది. ఈ వనరు (కొన్ని గిగాబైట్ల పరిమాణంలో) DAG అని పిలువబడుతుంది. ప్రతి 30000 బ్లాక్‌లకు DAG మార్చబడుతుంది, ఇది ఎపోక్ (సుమారు 5.2 రోజులు) అని పిలువబడే ~125 గంటల విండో మరియు రూపొందించడానికి కొంత సమయం పడుతుంది. DAG కేవలం బ్లాక్ ఎత్తుపై ఆధారపడి ఉంటుంది కాబట్టి, దానిని ముందుగా రూపొందించవచ్చు, కానీ అది కాకపోతే, క్లయింట్ ఒక బ్లాక్‌ను ఉత్పత్తి చేయడానికి ఈ ప్రక్రియ ముగిసే వరకు వేచి ఉండాలి. క్లయింట్లు DAGలను ముందుగానే రూపొందించి మరియు కాష్ చేయకపోతే, ప్రతి ఎపోక్ మార్పుపై నెట్‌వర్క్ భారీ బ్లాక్ ఆలస్యాన్ని ఎదుర్కోవచ్చు. ప్రూఫ్-ఆఫ్-వర్క్‌ను ధృవీకరించడానికి DAGని రూపొందించాల్సిన అవసరం లేదని గమనించండి, ముఖ్యంగా తక్కువ CPU మరియు చిన్న మెమరీ రెండింటితో ధృవీకరణను అనుమతిస్తుంది.

అల్గారిథం తీసుకునే సాధారణ మార్గం క్రింది విధంగా ఉంది:

  1. ఆ పాయింట్ వరకు బ్లాక్ హెడర్‌ల ద్వారా స్కాన్ చేయడం ద్వారా ప్రతి బ్లాక్‌కు లెక్కించబడే ఒక సీడ్ ఉంటుంది.
  2. సీడ్ నుండి, ఒకరు 16 MB సూడోరాండమ్ కాష్ను లెక్కించవచ్చు. లైట్ క్లయింట్లు కాష్‌ను నిల్వ చేస్తాయి.
  3. కాష్ నుండి, మనం 1 GB డేటాసెట్‌ను రూపొందించవచ్చు, డేటాసెట్‌లోని ప్రతి ఐటెమ్ కాష్ నుండి కొన్ని ఐటెమ్‌లపై మాత్రమే ఆధారపడి ఉంటుందనే లక్షణంతో. పూర్తి క్లయింట్లు మరియు మైనర్లు డేటాసెట్‌ను నిల్వ చేస్తాయి. డేటాసెట్ కాలక్రమేణా సరళంగా పెరుగుతుంది.
  4. మైనింగ్ అనేది డేటాసెట్ యొక్క యాదృచ్ఛిక స్లైస్‌లను పట్టుకుని, వాటిని కలిసి హాష్ చేయడాన్ని కలిగి ఉంటుంది. మీకు అవసరమైన డేటాసెట్ యొక్క నిర్దిష్ట భాగాలను పునరుత్పత్తి చేయడానికి కాష్‌ను ఉపయోగించడం ద్వారా తక్కువ మెమరీతో ధృవీకరణ చేయవచ్చు, కాబట్టి మీరు కాష్‌ను మాత్రమే నిల్వ చేయాలి.

ప్రతి 30000 బ్లాక్‌లకు ఒకసారి పెద్ద డేటాసెట్ నవీకరించబడుతుంది, కాబట్టి మైనర్ యొక్క అధికభాగం ప్రయత్నం డేటాసెట్‌ను చదవడం అవుతుంది, దానికి మార్పులు చేయడం కాదు.

నిర్వచనాలు

మేము క్రింది నిర్వచనాలను ఉపయోగిస్తాము:

'SHA3' ఉపయోగం

ఇథిరియం అభివృద్ధి SHA3 ప్రమాణం యొక్క అభివృద్ధితో ఏకకాలంలో జరిగింది, మరియు ప్రమాణాల ప్రక్రియ ఖరారు చేయబడిన హాష్ అల్గారిథం యొక్క ప్యాడింగ్‌లో ఆలస్యంగా మార్పు చేసింది, తద్వారా ఇథిరియం యొక్క "sha3_256" మరియు "sha3_512" హాష్‌లు ప్రామాణిక sha3 హాష్‌లు కావు, కానీ తరచుగా ఇతర సందర్భాలలో "Keccak-256" మరియు "Keccak-512" అని సూచించబడే ఒక వేరియంట్. చర్చను చూడండి, ఉదా., ఇక్కడ (opens in a new tab), ఇక్కడ (opens in a new tab), లేదా ఇక్కడ (opens in a new tab).

క్రింద అల్గారిథం యొక్క వివరణలో "sha3" హాష్‌లు ప్రస్తావించబడినందున దయచేసి దానిని గుర్తుంచుకోండి.

పారామితులు

ఈతాష్ యొక్క కాష్ మరియు డేటాసెట్ కోసం పారామితులు బ్లాక్ నంబర్‌పై ఆధారపడి ఉంటాయి. కాష్ పరిమాణం మరియు డేటాసెట్ పరిమాణం రెండూ సరళంగా పెరుగుతాయి; అయినప్పటికీ, చక్రీయ ప్రవర్తనకు దారితీసే ప్రమాదవశాత్తూ క్రమబద్ధతల ప్రమాదాన్ని తగ్గించడానికి మేము ఎల్లప్పుడూ సరళంగా పెరుగుతున్న పరిమితి కంటే తక్కువ ఉన్న అత్యధిక ప్రధాన సంఖ్యను తీసుకుంటాము.

డేటాసెట్ మరియు కాష్ పరిమాణం విలువల పట్టికలు అనుబంధంలో అందించబడ్డాయి.

కాష్ జనరేషన్

ఇప్పుడు, కాష్‌ను ఉత్పత్తి చేయడానికి మేము ఫంక్షన్‌ను నిర్దేశిస్తాము:

కాష్ ఉత్పత్తి ప్రక్రియలో మొదట 32 MB మెమరీని వరుసగా నింపడం, ఆపై స్ట్రిక్ట్ మెమరీ హార్డ్ హాషింగ్ ఫంక్షన్స్ (2014) (opens in a new tab) నుండి సెర్గియో డెమియన్ లెర్నర్ యొక్క RandMemoHash అల్గారిథం యొక్క రెండు పాస్‌లను ప్రదర్శించడం ఉంటుంది. అవుట్‌పుట్ 524288 64-బైట్ విలువల సమితి.

డేటా అగ్రిగేషన్ ఫంక్షన్

మేము కొన్ని సందర్భాల్లో XORకు నాన్-అసోసియేటివ్ ప్రత్యామ్నాయంగా FNV హాష్ (opens in a new tab) ద్వారా ప్రేరణ పొందిన అల్గారిథంను ఉపయోగిస్తాము. ఒక బైట్ (ఆక్టెట్)తో ప్రైమ్‌ను గుణించే FNV-1 స్పెక్ వలె కాకుండా, మేము పూర్తి 32-బిట్ ఇన్‌పుట్‌తో ప్రైమ్‌ను గుణిస్తామని గమనించండి.

FNV_PRIME = 0x01000193

def fnv(v1, v2):
    return ((v1 * FNV_PRIME) ^ v2) % 2**32

దయచేసి గమనించండి, పసుపు పత్రం fnvను v1*(FNV_PRIME ^ v2)గా నిర్దిష్టంగా పేర్కొన్నప్పటికీ, అన్ని ప్రస్తుత అమలులు నిరంతరం పైన పేర్కొన్న నిర్వచనాన్ని ఉపయోగిస్తాయి.

పూర్తి డేటాసెట్ గణన

పూర్తి 1 GB డేటాసెట్‌లోని ప్రతి 64-బైట్ ఐటెమ్ క్రింది విధంగా లెక్కించబడుతుంది:

ముఖ్యంగా, మేము 256 సూడోరాండమ్‌గా ఎంచుకున్న కాష్ నోడ్‌ల నుండి డేటాను కలుపుతాము, మరియు డేటాసెట్ నోడ్‌ను లెక్కించడానికి దానిని హాష్ చేస్తాము. పూర్తి డేటాసెట్ అప్పుడు దీని ద్వారా రూపొందించబడుతుంది:

def calc_dataset(full_size, cache):
    return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]

ప్రధాన లూప్

ఇప్పుడు, మేము ప్రధాన "హాషిమోటో"-వంటి లూప్‌ను నిర్దేశిస్తాము, ఇక్కడ ఒక నిర్దిష్ట హెడర్ మరియు నాన్స్ కోసం మా చివరి విలువను ఉత్పత్తి చేయడానికి పూర్తి డేటాసెట్ నుండి డేటాను సమగ్రపరుస్తాము. దిగువ కోడ్‌లో, header అనేది ట్రంకేటెడ్ బ్లాక్ హెడర్ యొక్క RLP ప్రాతినిధ్యం యొక్క SHA3-256 _హాష్‌_ను సూచిస్తుంది, అంటే mixHash మరియు nonce ఫీల్డ్‌లను మినహాయించి ఒక హెడర్. బిగ్-ఎండియన్ క్రమంలో nonce అనేది 64 బిట్ అన్‌సైన్డ్ పూర్ణసంఖ్య యొక్క ఎనిమిది బైట్‌లు. కాబట్టి nonce[::-1] అనేది ఆ విలువ యొక్క ఎనిమిది-బైట్ లిటిల్-ఎండియన్ ప్రాతినిధ్యం:

ముఖ్యంగా, మేము 128 బైట్‌ల వెడల్పు ఉన్న ఒక "మిక్స్"ను నిర్వహిస్తాము మరియు పూర్తి డేటాసెట్ నుండి 128 బైట్‌లను పదేపదే వరుసగా పొందుతాము మరియు దానిని మిక్స్‌తో కలపడానికి fnv ఫంక్షన్‌ను ఉపయోగిస్తాము. 128 బైట్‌ల సీక్వెన్షియల్ యాక్సెస్ ఉపయోగించబడుతుంది, తద్వారా అల్గారిథం యొక్క ప్రతి రౌండ్ ఎల్లప్పుడూ RAM నుండి పూర్తి పేజీని పొందుతుంది, ఇది ASICలు సిద్ధాంతపరంగా నివారించగల ట్రాన్స్‌లేషన్ లుక్‌అసైడ్ బఫర్ మిస్‌లను తగ్గిస్తుంది.

ఈ అల్గారిథం యొక్క అవుట్‌పుట్ కావలసిన లక్ష్యం కంటే తక్కువగా ఉంటే, అప్పుడు నాన్స్ చెల్లుబాటు అవుతుంది. చివరలో sha3_256 యొక్క అదనపు అప్లికేషన్, కనీసం కొంత పని జరిగిందని నిరూపించడానికి అందించగల ఒక మధ్యంతర నాన్స్ ఉందని నిర్ధారిస్తుంది; ఈ శీఘ్ర బాహ్య PoW ధృవీకరణ యాంటీ-DDoS ప్రయోజనాల కోసం ఉపయోగించబడుతుంది. ఫలితం ఒక నిష్పక్షపాత, 256-బిట్ సంఖ్య అని గణాంక హామీని అందించడానికి కూడా ఇది ఉపయోగపడుతుంది.

మైనింగ్

మైనింగ్ అల్గారిథం క్రింది విధంగా నిర్వచించబడింది:

def mine(full_size, dataset, header, difficulty):
    # అదే అంకెపై హాష్‌తో పోల్చడానికి లక్ష్యాన్ని జీరో-ప్యాడ్ చేయండి
    target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
    from random import randint
    nonce = randint(0, 2**64)
    while hashimoto_full(full_size, dataset, header, nonce) > target:
        nonce = (nonce + 1) % 2**64
    return nonce

సీడ్ హాష్‌ను నిర్వచించడం

ఒక నిర్దిష్ట బ్లాక్ పైన మైన్ చేయడానికి ఉపయోగించే సీడ్ హాష్‌ను లెక్కించడానికి, మేము క్రింది అల్గారిథంను ఉపయోగిస్తాము:

 def get_seedhash(block):
     s = '\x00' * 32
     for i in range(block.number // EPOCH_LENGTH):
         s = serialize_hash(sha3_256(s))
     return s

సున్నితమైన మైనింగ్ మరియు ధృవీకరణ కోసం, భవిష్యత్ సీడ్ హాష్‌లు మరియు డేటాసెట్‌లను ఒక ప్రత్యేక థ్రెడ్‌లో ముందుగా గణించాలని మేము సిఫార్సు చేస్తున్నాము.

మరింత సమాచారం

మీకు సహాయపడిన కమ్యూనిటీ వనరు గురించి తెలుసా? ఈ పేజీని సవరించి, దాన్ని జోడించండి!

అనుబంధం

మీరు పైన పేర్కొన్న పైథాన్ స్పెక్ను కోడ్‌గా అమలు చేయడానికి ఆసక్తి కలిగి ఉంటే, క్రింది కోడ్‌ను ముందుగా చేర్చాలి.

డేటా పరిమాణాలు

క్రింది శోధన పట్టికలు డేటా పరిమాణాలు మరియు కాష్ పరిమాణాల యొక్క సుమారుగా 2048 పట్టిక చేయబడిన ఎపోక్‌లను అందిస్తాయి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?