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

ఎథాష్

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

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

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

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

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

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

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

నిర్వచనాలు

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

'SHA3' వినియోగం

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

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

పారామితులు

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

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

కాష్ ఉత్పత్తి

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

కాష్ ఉత్పత్తి ప్రక్రియలో మొదట 32 MB మెమరీని వరుసగా నింపడం, ఆపై Strict Memory Hard Hashing Functions (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 ఫంక్షన్‌ను ఉపయోగిస్తాము. అల్గారిథమ్ యొక్క ప్రతి రౌండ్ ఎల్లప్పుడూ RAM నుండి పూర్తి పేజీని పొందేలా 128 బైట్ల సీక్వెన్షియల్ యాక్సెస్ ఉపయోగించబడుతుంది, ఇది 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

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

మరింత చదవడానికి

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

అనుబంధం

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

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

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