पायथन ब्लॉकचेन - माइनर्स बनाना

खनन को सक्षम करने के लिए, हमें एक खनन कार्य विकसित करना होगा। खनन कार्यशीलता को दिए गए संदेश स्ट्रिंग पर एक डाइजेस्ट उत्पन्न करने और प्रूफ-ऑफ-वर्क प्रदान करने की आवश्यकता होती है। आइए इस अध्याय में इसकी चर्चा करते हैं।

संदेश डाइजेस्ट फ़ंक्शन

हम एक उपयोगिता फ़ंक्शन लिखेंगे जिसे कहा जाता है sha256 दिए गए संदेश पर एक डाइजेस्ट बनाने के लिए -

def sha256(message):
return hashlib.sha256(message.encode('ascii')).hexdigest()

sha256 फ़ंक्शन एक लेता है message एक पैरामीटर के रूप में, यह ASCII को एनकोड करता है, एक हेक्साडेसिमल डाइजेस्ट उत्पन्न करता है और कॉलर को वैल्यू देता है।

खनन कार्य

हम अब विकास करते हैं mineफ़ंक्शन जो हमारी खनन रणनीति को लागू करता है। इस मामले में हमारी रणनीति उस दिए गए संदेश पर एक हैश उत्पन्न करना होगी जो किसी दिए गए नंबर 1 के साथ उपसर्ग करता है। 1 की दी गई संख्या को एक पैरामीटर के रूप में निर्दिष्ट किया गया हैmine कठिनाई स्तर के रूप में निर्दिष्ट कार्य।

उदाहरण के लिए, यदि आप 2 का कठिनाई स्तर निर्दिष्ट करते हैं, तो दिए गए संदेश पर उत्पन्न हैश दो 1 के साथ शुरू होना चाहिए - जैसे 11xxxxxxx। यदि कठिनाई स्तर 3 है, तो उत्पन्न हैश को तीन 1 से शुरू करना चाहिए - जैसे 111xxxxxxxx। इन आवश्यकताओं को देखते हुए, हम अब नीचे दिए गए चरणों में दिखाए गए अनुसार खनन कार्य को विकसित करेंगे।

चरण 1

माइनिंग फ़ंक्शन दो पैरामीटर लेता है - संदेश और कठिनाई स्तर।

def mine(message, difficulty=1):

चरण 2

कठिनाई का स्तर 1 से अधिक या उसके बराबर होना चाहिए, हम इसे निम्न कथन के साथ सुनिश्चित करते हैं -

assert difficulty >= 1

चरण 3

हम एक बनाते हैं prefix चर सेट कठिनाई स्तर का उपयोग कर।

prefix = '1' * difficulty

ध्यान दें कि यदि कठिनाई स्तर 2 है, तो उपसर्ग "11" होगा और यदि कठिनाई स्तर 3 है, तो उपसर्ग "111" होगा, और इसी तरह। हम जाँचेंगे कि क्या यह उपसर्ग संदेश के उत्पन्न पाचन में मौजूद है। संदेश को पचाने के लिए, हम निम्नलिखित दो पंक्तियों का उपयोग करते हैं -

for i in range(1000):
   digest = sha256(str(hash(message)) + str(i))

हम एक नया नंबर जोड़ते रहते हैं iप्रत्येक पुनरावृत्ति में संदेश हैश के लिए और संयुक्त संदेश पर एक नया पाचन उत्पन्न करते हैं। के इनपुट के रूप मेंsha256 हर पुनरावृत्ति में कार्य परिवर्तन, digestमूल्य भी बदल जाएगा। हम यह जाँचते हैं कि क्याdigest मान ऊपर-सेट है prefix

if digest.startswith(prefix):

यदि शर्त पूरी हो जाती है, तो हम इसे समाप्त कर देंगे for पाश और वापसी digest कॉलर के लिए मूल्य।

पूरा mine कोड यहाँ दिखाया गया है -

def mine(message, difficulty=1):
   assert difficulty >= 1
   prefix = '1' * difficulty
   for i in range(1000):
      digest = sha256(str(hash(message)) + str(i))
      if digest.startswith(prefix):
         print ("after " + str(i) + " iterations found nonce: "+ digest)
      return digest

आपकी समझ के लिए, हमने जोड़ा है print बयान जो पाचन मूल्य और पुनरावृत्तियों की संख्या को छापता है जो फ़ंक्शन से लौटने से पहले स्थिति को पूरा करता है।

परीक्षण खनन समारोह

हमारे खनन कार्य का परीक्षण करने के लिए, बस निम्नलिखित कथन को निष्पादित करें -

mine ("test message", 2)

जब आप उपरोक्त कोड चलाते हैं, तो आपको नीचे दिए गए आउटपुट के समान दिखाई देगा -

after 138 iterations found nonce:
11008a740eb2fa6bf8d55baecda42a41993ca65ce66b2d3889477e6bfad1484c

ध्यान दें कि उत्पन्न पाचन "11" से शुरू होता है। यदि आप कठिनाई स्तर को 3 में बदलते हैं, तो उत्पन्न पाचन "111" से शुरू होगा, और निश्चित रूप से, इसे शायद अधिक संख्या में पुनरावृत्तियों की आवश्यकता होगी। जैसा कि आप देख सकते हैं, अधिक प्रसंस्करण शक्ति वाला एक खनिक पहले दिए गए संदेश को माइन करने में सक्षम होगा। इस तरह से खनिक अपना राजस्व अर्जित करने के लिए एक-दूसरे के साथ प्रतिस्पर्धा करते हैं।

अब, हम अपने ब्लॉकचेन में और ब्लॉक जोड़ने के लिए तैयार हैं। इसे हम अपने अगले अध्याय में सीखते हैं।