मुख्य सामग्री पर जाएं
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" हैश का उल्लेख किया गया है।

पैरामीटर्स

एथैश के कैश और डेटासेट के पैरामीटर ब्लॉक संख्या पर निर्भर करते हैं। कैश का आकार और डेटासेट का आकार दोनों रैखिक रूप से बढ़ते हैं; हालाँकि, हम हमेशा चक्रीय व्यवहार की ओर ले जाने वाली आकस्मिक नियमितताओं के जोखिम को कम करने के लिए रैखिक रूप से बढ़ती सीमा के नीचे उच्चतम अभाज्य (prime) लेते हैं।

डेटासेट और कैश आकार मानों की तालिकाएँ परिशिष्ट में प्रदान की गई हैं।

कैश जनरेशन

अब, हम कैश बनाने के लिए फ़ंक्शन निर्दिष्ट करते हैं:

कैश उत्पादन प्रक्रिया में पहले क्रमिक रूप से 32 MB मेमोरी भरना शामिल है, फिर Strict Memory Hard Hashing Functions (2014) (opens in a new tab) से Sergio Demian Lerner के RandMemoHash एल्गोरिदम के दो पास निष्पादित करना शामिल है। आउटपुट 524288 64-बाइट मानों का एक सेट है।

डेटा एग्रीगेशन फ़ंक्शन

हम कुछ मामलों में XOR के गैर-साहचर्य (non-associative) विकल्प के रूप में FNV हैश (opens in a new tab) से प्रेरित एक एल्गोरिदम का उपयोग करते हैं। ध्यान दें कि हम अभाज्य को पूर्ण 32-बिट इनपुट के साथ गुणा करते हैं, FNV-1 स्पेक के विपरीत जो अभाज्य को बदले में एक बाइट (ऑक्टेट) के साथ गुणा करता है।

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)]

मुख्य लूप

अब, हम मुख्य "hashimoto"-जैसे लूप को निर्दिष्ट करते हैं, जहां हम किसी विशेष हेडर और नॉन्स के लिए अपना अंतिम मान उत्पन्न करने के लिए पूर्ण डेटासेट से डेटा एकत्र करते हैं। नीचे दिए गए कोड में, header एक कटे हुए (truncated) ब्लॉक हेडर के 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

ध्यान दें कि सुचारू खनन और सत्यापन के लिए, हम एक अलग थ्रेड में भविष्य के सीडहैश और डेटासेट की पूर्व-गणना करने की सलाह देते हैं।

आगे की पढ़ाई

क्या आप किसी ऐसे सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की? इस पेज को संपादित करें और इसे जोड़ें!

परिशिष्ट

यदि आप उपरोक्त Python स्पेक को कोड के रूप में चलाने में रुचि रखते हैं तो निम्नलिखित कोड को पहले जोड़ा जाना चाहिए।

डेटा आकार

निम्नलिखित लुकअप तालिकाएँ डेटा आकार और कैश आकार के लगभग 2048 सारणीबद्ध एपॉक प्रदान करती हैं।