मुख्य सामग्री पर जाएं
Change page

एथाश

एथाश एथेरियम का प्रूफ-ऑफ-वर्क माइनिंग एल्गोरिथम था। काम का सबूत अब पूरी तरह से बंद कर दिया गया है और एथेरियम अब इसके बजाय हिस्सेदारी के सबूत का उपयोग करके सुरक्षित है। मर्ज, हिस्सेदारी के सबूत और स्टेकिंग पर और पढ़ें। यह पृष्ठ ऐतिहासिक रुचि के लिए है!

एथाश डैगर-हाशिमोटो एल्गोरिथम का एक संशोधित संस्करण है। एथाश काम का सबूत मेमोरी हार्ड (opens in a new tab) है, जिससे एल्गोरिथम को ASIC प्रतिरोधी माना जाता था। एथाश ASIC को अंततः विकसित किया गया था लेकिन GPU माईनिंग तब तक एक व्यवहार्य विकल्प था जब तक कि प्रूफ-ऑफ-वर्क बंद नहीं किया गया था। एथाश का उपयोग अभी भी अन्य गैर-एथेरियम प्रूफ-ऑफ-वर्क नेटवर्क पर अन्य सिक्कों को माइन करने के लिए किया जाता है।

एथाश कैसे काम करता है?

मेमोरी कठोरता प्रूफ-ऑफ-वर्क एल्गोरिथम के साथ प्राप्त की जाती है जिसके लिए नॉन्स और ब्लॉक हेडर पर निर्भर एक निश्चित संसाधन के सबसेट को चुनने की आवश्यकता होती है। इस संसाधन (आकार में कुछ गीगाबाइट) को DAG कहा जाता है। DAG को हर 30000 ब्लॉक में बदल दिया जाता है, एक ~ 125 घंटे की विंडो जिसे एक युग (लगभग 5.2 दिन) कहा जाता है और उत्पन्न होने में कुछ समय लगता है। चूंकि 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 का अतिरिक्त एप्लिकेशन यह सुनिश्चित करता है कि एक मध्यवर्ती नॉन्स मौजूद है जिसे यह साबित करने के लिए प्रदान किया जा सकता है कि कम से कम थोड़ी मात्रा में काम किया गया था; इस त्वरित बाहरी काम के सबूत सत्यापन का उपयोग एंटी-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 सारणीबद्ध युगों को प्रदान करती हैं।

पेज का अंतिम अपडेट: 15 अप्रैल 2026

क्या यह लेख उपयोगी था?