मुख्य आशयावर जा
Change page

इथहॅश

इथहॅश हा इथेरियमचा प्रूफ-ऑफ-वर्क (PoW) खनन अल्गोरिदम होता. प्रूफ-ऑफ-वर्क आता पूर्णपणे बंद केले गेले आहे आणि त्याऐवजी इथेरियम आता प्रूफ-ऑफ-स्टेक (PoS) वापरून सुरक्षित केले जाते. द मर्ज, प्रूफ-ऑफ-स्टेक (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 ला नॉन-असोसिएटिव्ह पर्याय म्हणून FNV हॅश (opens in a new tab) द्वारे प्रेरित अल्गोरिदम वापरतो. लक्षात घ्या की आम्ही मूळ संख्येला (prime) पूर्ण 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)]

मुख्य लूप

आता, आम्ही मुख्य "हाशिमोटो"-सारखे लूप निर्दिष्ट करतो, जिथे आम्ही विशिष्ट हेडर आणि नॉन्ससाठी आमचे अंतिम मूल्य तयार करण्यासाठी पूर्ण डेटासेटमधून डेटा एकत्र करतो. खालील कोडमध्ये, header हे ट्रंकेटेड ब्लॉक हेडरच्या RLP सादरीकरणाचे SHA3-256 हॅश दर्शवते, म्हणजेच, mixHash आणि nonce फील्ड वगळलेल्या हेडरचे. nonce हे बिग-एन्डियन क्रमाने 64 बिट अनसाइन्ड इंटिजरचे आठ बाइट्स आहेत. त्यामुळे nonce[::-1] हे त्या मूल्याचे आठ-बाइट लिटल-एन्डियन सादरीकरण आहे:

मूलत:, आम्ही 128 बाइट्स रुंद "मिक्स" राखतो, आणि पूर्ण डेटासेटमधून वारंवार क्रमाने 128 बाइट्स आणतो आणि मिक्ससह एकत्र करण्यासाठी fnv फंक्शन वापरतो. 128 बाइट्सचा अनुक्रमिक ॲक्सेस वापरला जातो जेणेकरून अल्गोरिदमची प्रत्येक फेरी नेहमी RAM मधून पूर्ण पृष्ठ आणते, ट्रान्सलेशन लुकअसाइड बफर मिसेस कमी करते जे ASICs सैद्धांतिकदृष्ट्या टाळू शकतील.

जर या अल्गोरिदमचे आउटपुट इच्छित लक्ष्यापेक्षा कमी असेल, तर नॉन्स वैध आहे. लक्षात घ्या की शेवटी 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 सारणीबद्ध पर्व प्रदान करतात.