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

एथहॅश

एथहॅश हा Ethereum चा प्रूफ-ऑफ-वर्क मायनिंग अल्गोरिदम होता. प्रूफ-ऑफ-वर्क आता पूर्णपणे बंद केले आहे आणि Ethereum आता त्याऐवजी प्रूफ-ऑफ-स्टेक वापरून सुरक्षित केले आहे. द मर्ज, प्रूफ-ऑफ-स्टेक आणि स्टेकिंग वर अधिक वाचा. हे पृष्ठ केवळ ऐतिहासिक माहितीसाठी आहे!

एथहॅश हे डॅगर-हाशिमोटो अल्गोरिदमची सुधारित आवृत्ती आहे. एथहॅश प्रूफ-ऑफ-वर्क हे मेमरी हार्ड (opens in a new tab) आहे, ज्यामुळे अल्गोरिदम ASIC प्रतिरोधक बनेल असे मानले जात होते. अखेरीस एथहॅश ASICs विकसित केले गेले परंतु प्रूफ-ऑफ-वर्क बंद होईपर्यंत GPU मायनिंग हा एक व्यवहार्य पर्याय होता. इतर नॉन-Ethereum प्रूफ-ऑफ-वर्क नेटवर्क्सवर इतर कॉइन्स माइन करण्यासाठी एथहॅश अजूनही वापरले जाते.

एथहॅश कसे कार्य करते?

मेमरी हार्डनेस एका प्रूफ ऑफ वर्क अल्गोरिदमद्वारे प्राप्त केली जाते ज्यासाठी नॉन्स आणि ब्लॉक हेडरवर अवलंबून असलेल्या निश्चित रिसोर्समधून उपसंचांची निवड करणे आवश्यक असते. या रिसोर्सला (आकारात काही गीगाबाईट्स) DAG म्हटले जाते. DAG प्रत्येक ३०००० ब्लॉक्सनंतर बदलला जातो, जो ~१२५-तासांचा कालावधी आहे ज्याला इपॉक (अंदाजे ५.२ दिवस) म्हणतात आणि तो तयार होण्यासाठी थोडा वेळ लागतो. DAG केवळ ब्लॉकच्या उंचीवर अवलंबून असल्याने, तो पूर्व-उत्पन्न केला जाऊ शकतो, परंतु तसे नसल्यास क्लायंटला ब्लॉक तयार करण्यासाठी या प्रक्रियेच्या शेवटपर्यंत थांबावे लागेल. जर क्लायंट्सनी वेळेपूर्वी DAGs पूर्व-उत्पन्न आणि कॅशे केले नाहीत, तर नेटवर्कला प्रत्येक इपॉक संक्रमणावर मोठ्या ब्लॉक विलंबाचा सामना करावा लागू शकतो. लक्षात घ्या की प्रूफ-ऑफ-वर्क सत्यापित करण्यासाठी DAG तयार करण्याची आवश्यकता नाही, ज्यामुळे कमी CPU आणि कमी मेमरीसह सत्यापन शक्य होते.

अल्गोरिदम ज्या सामान्य मार्गाचा अवलंब करतो तो खालीलप्रमाणे आहे:

  1. एक सीड अस्तित्वात आहे जी प्रत्येक ब्लॉकसाठी त्या बिंदूपर्यंतच्या ब्लॉक हेडर्समधून स्कॅन करून मोजली जाऊ शकते.
  2. सीडमधून, कोणीही १६ MB स्युडोरँडम कॅशे मोजू शकतो. लाइट क्लायंट कॅशे संग्रहित करतात.
  3. कॅशेमधून, आम्ही १ GB डेटासेट तयार करू शकतो, ज्यामध्ये डेटासेटमधील प्रत्येक आयटम कॅशेमधील केवळ काही आयटमवर अवलंबून असतो. पूर्ण क्लायंट आणि मायनर्स डेटासेट संग्रहित करतात. डेटासेट वेळेनुसार रेषीयपणे वाढतो.
  4. मायनिंगमध्ये डेटासेटचे यादृच्छिक स्लाइस घेणे आणि त्यांना एकत्र हॅश करणे समाविष्ट आहे. तुम्हाला आवश्यक असलेल्या डेटासेटचे विशिष्ट तुकडे पुन्हा तयार करण्यासाठी कॅशे वापरून कमी मेमरीसह सत्यापन केले जाऊ शकते, म्हणून तुम्हाला फक्त कॅशे संग्रहित करण्याची आवश्यकता आहे.

मोठा डेटासेट प्रत्येक ३०००० ब्लॉक्सनंतर एकदा अपडेट केला जातो, त्यामुळे मायनरचा बहुतांश प्रयत्न डेटासेट वाचण्यात जाईल, त्यात बदल करण्यात नाही.

व्याख्या

आम्ही खालील व्याख्या वापरतो:

'SHA3' चा वापर

Ethereum चा विकास SHA3 मानकाच्या विकासासोबतच झाला आणि मानकीकरण प्रक्रियेने अंतिम हॅश अल्गोरिदमच्या पॅडिंगमध्ये उशीरा बदल केला, त्यामुळे Ethereum चे "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" हॅशचा उल्लेख आहे.

मापदंड

एथहॅशच्या कॅशे आणि डेटासेटसाठी पॅरामीटर्स ब्लॉक क्रमांकावर अवलंबून असतात. कॅशे आकार आणि डेटासेट आकार दोन्ही रेषीयपणे वाढतात; तथापि, चक्रीय वर्तणुकीला कारणीभूत होणाऱ्या अपघाती नियमिततेचा धोका कमी करण्यासाठी आम्ही नेहमी रेषीय वाढत्या थ्रेशोल्डच्या खाली सर्वोच्च अविभाज्य संख्या घेतो.

डेटासेट आणि कॅशे आकाराच्या मूल्यांचे तक्ते परिशिष्टात दिले आहेत.

कॅशे निर्मिती

आता, आम्ही कॅशे तयार करण्याचे कार्य निर्दिष्ट करतो:

कॅशे उत्पादन प्रक्रियेत प्रथम क्रमाने ३२ MB मेमरी भरणे, नंतर सर्जियो डेमियन लर्नरच्या स्ट्रिक्ट मेमरी हार्ड हॅशिंग फंक्शन्स (२०१४) (opens in a new tab) मधील RandMemoHash अल्गोरिदमच्या दोन फेऱ्या करणे समाविष्ट आहे. आउटपुट ५२४२८८ ६४-बाइट मूल्यांचा एक संच आहे.

डेटा एकत्रीकरण कार्य

आम्ही काही प्रकरणांमध्ये XOR साठी नॉन-असोसिएटिव्ह पर्याय म्हणून FNV हॅश (opens in a new tab) द्वारे प्रेरित अल्गोरिदम वापरतो. लक्षात घ्या की आम्ही अविभाज्य संख्येला पूर्ण ३२-बिट इनपुटसह गुणतो, याउलट FNV-1 स्पेसिफिकेशन अविभाज्य संख्येला एका बाइट (ऑक्टेट) ने गुणते.

FNV_PRIME = 0x01000193

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

कृपया लक्षात घ्या, जरी यलो पेपरमध्ये fnv हे v1*(FNV_PRIME ^ v2) म्हणून निर्दिष्ट केले असले तरी, सध्याची सर्व अंमलबजावणी सातत्याने वरील व्याख्या वापरतात.

पूर्ण डेटासेट गणना

पूर्ण १ GB डेटासेटमधील प्रत्येक ६४-बाइट आयटम खालीलप्रमाणे मोजला जातो:

मूलतः, आम्ही २५६ स्युडोरँडमली निवडलेल्या कॅशे नोड्समधील डेटा एकत्र करतो आणि डेटासेट नोडची गणना करण्यासाठी ते हॅश करतो. संपूर्ण डेटासेट नंतर याद्वारे तयार केला जातो:

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 हे बिग-एन्डियन क्रमाने ६४ बिट अनसाईन्ड इंटीजरचे आठ बाइट्स आहेत. त्यामुळे nonce[::-1] हे त्या मूल्याचे आठ-बाइट लिटिल-एन्डियन प्रतिनिधित्व आहे:

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

जर या अल्गोरिदमचे आउटपुट इच्छित लक्ष्यापेक्षा कमी असेल, तर नॉन्स वैध आहे. लक्षात घ्या की शेवटी sha3_256 चा अतिरिक्त अनुप्रयोग हे सुनिश्चित करतो की एक मध्यवर्ती नॉन्स अस्तित्वात आहे जो किमान थोडे काम केले आहे हे सिद्ध करण्यासाठी प्रदान केला जाऊ शकतो; हे जलद बाह्य PoW सत्यापन अँटी-DDoS हेतूंसाठी वापरले जाऊ शकते. हे परिणाम एक निःपक्षपाती, २५६-बिट संख्या आहे याची सांख्यिकीय खात्री देण्याचे काम देखील करते.

मायनिंग

मायनिंग अल्गोरिदम खालीलप्रमाणे परिभाषित केला आहे:

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

लक्षात घ्या की सुरळीत मायनिंग आणि पडताळणीसाठी, आम्ही भविष्यातील सीडहॅश आणि डेटासेट एका वेगळ्या थ्रेडमध्ये पूर्व-गणना करण्याची शिफारस करतो.

पुढील वाचन

तुम्हाला मदत केलेल्या सामुदायिक संसाधनाबद्दल माहिती आहे का? हे पृष्ठ संपादित करा आणि ते जोडा!_

परिशिष्ट

जर तुम्हाला वरील पायथन स्पेसिफिकेशन कोड म्हणून चालवण्यात स्वारस्य असेल तर खालील कोड आधी जोडला पाहिजे.

डेटा आकार

खालील लुकअप टेबल अंदाजे २०४८ सारणीबद्ध इपॉक्ससाठी डेटा आकार आणि कॅशे आकार प्रदान करतात.

पृष्ठ शेवटचे अपडेट: 15 एप्रिल, 2026

हा लेख उपयुक्त होता का?