पायथन ब्लॉकचेन - त्वरित गाइड

ब्लॉकचैन पर ट्यूटोरियल में, हमने ब्लॉकचैन के पीछे के सिद्धांत के बारे में विस्तार से सीखा है। ब्लॉकचेन दुनिया की सबसे लोकप्रिय डिजिटल मुद्रा बिटकॉइन के पीछे मौलिक बिल्डिंग ब्लॉक है। ट्यूटोरियल पूरी तरह से ब्लॉकचेन आर्किटेक्चर को समझाते हुए बिटकॉइन की पेचीदगियों से गहराई से निपटता है। अगला कदम हमारे अपने ब्लॉकचेन का निर्माण करना है।

सातोशी नाकामोटो ने बिटकॉइन नामक दुनिया में पहली आभासी मुद्रा बनाई। बिटकॉइन की सफलता को देखते हुए, कई अन्य लोगों ने अपनी आभासी मुद्राएं बनाईं। कुछ का नाम रखने के लिए - लिटिकोइन, ज़कैश, और इसी तरह।

अब, आप अपनी मुद्रा लॉन्च करना भी पसंद कर सकते हैं। इसे हम TPCoin (TutorialsPoint Coin) कहते हैं। आप TPCoin के साथ सौदा करने वाले सभी लेनदेन को रिकॉर्ड करने के लिए एक ब्लॉकचेन लिखेंगे। TPCoin का इस्तेमाल पिज्जा, बर्गर, सलाद आदि खरीदने के लिए किया जा सकता है। ऐसे अन्य सेवा प्रदाता भी हो सकते हैं जो आपके नेटवर्क से जुड़ेंगे और अपनी सेवाओं को देने के लिए TPCoin को मुद्रा के रूप में स्वीकार करना शुरू करेंगे। संभावनाएं अनंत हैं।

इस ट्यूटोरियल में, हम समझते हैं कि इस तरह की प्रणाली का निर्माण कैसे करें और बाजार में अपनी खुद की डिजिटल मुद्रा लॉन्च करें।

ब्लॉकचैन परियोजना विकास में शामिल घटक

संपूर्ण ब्लॉकचेन परियोजना के विकास में तीन प्रमुख घटक शामिल हैं -

  • Client
  • Miners
  • Blockchain

ग्राहक

क्लाइंट वह है जो अन्य विक्रेताओं से सामान खरीदेगा। ग्राहक स्वयं एक विक्रेता बन सकता है और अपने द्वारा आपूर्ति की जाने वाली वस्तुओं के खिलाफ दूसरों से धन स्वीकार करेगा। हम यह मान लेते हैं कि ग्राहक टीपीसीईएन के एक आपूर्तिकर्ता और प्राप्तकर्ता दोनों हो सकते हैं। इस प्रकार, हम अपने कोड में एक ग्राहक वर्ग बनाएंगे जिसमें पैसे भेजने और प्राप्त करने की क्षमता होगी।

खान में काम करनेवाला

माइनर वह है जो लेन-देन पूल से लेन-देन करता है और उन्हें एक ब्लॉक में इकट्ठा करता है। खनन करने वाले को खनन का इनाम प्राप्त करने के लिए वैध प्रमाण देना होगा। माइनर शुल्क के रूप में जो भी पैसा इकट्ठा करता है, वह उसके पास रखने के लिए होगा। वह उस पैसे को नेटवर्क पर अन्य पंजीकृत विक्रेताओं से सामान या सेवाएं खरीदने पर खर्च कर सकता है, जिस तरह से ऊपर वर्णित क्लाइंट करता है।

Blockchain

अंत में, एक ब्लॉकचेन एक डेटा संरचना है जो सभी कालानुक्रमिक खंडों को कालानुक्रमिक क्रम में श्रृंखलाबद्ध करता है। यह श्रृंखला अपरिवर्तनीय है और इस प्रकार गुस्सा-सबूत है।

आप एक नए Jupyter नोटबुक में प्रत्येक चरण में प्रस्तुत कोड टाइप करके इस ट्यूटोरियल का अनुसरण कर सकते हैं। वैकल्पिक रूप से, आप से पूरी Jupyter नोटबुक डाउनलोड कर सकते हैं www.anaconda.com ।

अगले अध्याय में, हम एक ग्राहक विकसित करेंगे जो हमारे ब्लॉकचेन सिस्टम का उपयोग करता है।

एक ग्राहक वह होता है जो TPCoins रखता है और अपने स्वयं के नेटवर्क सहित अन्य विक्रेताओं से माल / सेवाओं के लिए लेनदेन करता है। हमें परिभाषित करना चाहिएClientइस उद्देश्य के लिए कक्षा। क्लाइंट के लिए विश्व स्तर पर विशिष्ट पहचान बनाने के लिए, हम PKI (पब्लिक की इन्फ्रास्ट्रक्चर) का उपयोग करते हैं। इस अध्याय में, हम इस बारे में विस्तार से बात करते हैं।

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

विकसित करने के लिए Clientवर्ग और परियोजना में बाकी कोड के लिए, हमें कई पायथन पुस्तकालयों को आयात करने की आवश्यकता होगी। ये नीचे सूचीबद्ध हैं -

# import libraries
import hashlib
import random
import string
import json
import binascii
import numpy as np
import pandas as pd
import pylab as pl
import logging
import datetime
import collections

उपरोक्त मानक पुस्तकालयों के अतिरिक्त, हम अपने लेन-देन पर हस्ताक्षर करने जा रहे हैं, वस्तुओं का हैश आदि बना रहे हैं। इसके लिए आपको निम्नलिखित पुस्तकालयों को आयात करने की आवश्यकता होगी -

# following imports are required by PKI
import Crypto
import Crypto.Random
from Crypto.Hash import SHA
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5

अगले अध्याय में, हम ग्राहक वर्ग के बारे में बात करते हैं।

Client कक्षा उत्पन्न करता है private तथा public अंतर्निहित पायथन का उपयोग करके कुंजी RSAकलन विधि। इच्छुक पाठक को संदर्भित कर सकता हैthis tutorialRSA के कार्यान्वयन के लिए। ऑब्जेक्ट इनिशियलाइज़ेशन के दौरान, हम निजी और सार्वजनिक कुंजियाँ बनाते हैं और उदाहरण चर में उनके मूल्यों को संग्रहीत करते हैं।

self._private_key = RSA.generate(1024, random)
self._public_key = self._private_key.publickey()

ध्यान दें कि आपको अपनी निजी कुंजी कभी नहीं खोनी चाहिए। रिकॉर्ड रखने के लिए, उत्पन्न निजी कुंजी को एक सुरक्षित बाहरी भंडारण पर कॉपी किया जा सकता है या आप बस कागज के एक टुकड़े पर इसे ASCII प्रतिनिधित्व लिख सकते हैं।

उत्पन्न हुआ publicकुंजी ग्राहक की पहचान के रूप में उपयोग किया जाएगा। इसके लिए, हम एक संपत्ति को परिभाषित करते हैं जिसे कहा जाता हैidentity सार्वजनिक कुंजी की HEX प्रतिनिधित्व लौटाता है।

@property
   def identity(self):
      return
binascii.hexlify(self._public_key.exportKey(format='DER'))
.decode('ascii')

identityप्रत्येक ग्राहक के लिए अद्वितीय है और सार्वजनिक रूप से उपलब्ध कराया जा सकता है। इसका उपयोग करके कोई भी व्यक्ति आपको आभासी मुद्रा भेज सकेगाidentity और यह आपके बटुए में जुड़ जाएगा।

के लिए पूर्ण कोड Client वर्ग यहाँ दिखाया गया है -

class Client:
   def __init__(self):
      random = Crypto.Random.new().read
      self._private_key = RSA.generate(1024, random)
      self._public_key = self._private_key.publickey()
      self._signer = PKCS1_v1_5.new(self._private_key)

   @property
   def identity(self):
      return
binascii.hexlify(self._public_key.exportKey(format='DER')).decode('ascii')

परीक्षण ग्राहक

अब, हम कोड लिखेंगे जो यह वर्णन करेगा कि कैसे उपयोग करना है Client वर्ग -

Dinesh = Client()
print (Dinesh.identity)

उपरोक्त कोड का एक उदाहरण बनाता है Client और इसे चर को सौंपता है Dinesh। हम सार्वजनिक कुंजी प्रिंट करते हैंDinesh फोन करके identityतरीका। आउटपुट यहाँ दिखाया गया है -

30819f300d06092a864886f70d010101050003818d0030818902818100b547fafceeb131e07
0166a6b23fec473cce22c3f55c35ce535b31d4c74754fecd820aa94c1166643a49ea5f49f72
3181ff943eb3fdc5b2cb2db12d21c06c880ccf493e14dd3e93f3a9e175325790004954c34d3
c7bc2ccc9f0eb5332014937f9e49bca9b7856d351a553d9812367dc8f2ac734992a4e6a6ff6
6f347bd411d07f0203010001

अब, हम अगले अध्याय में लेनदेन करने के लिए आगे बढ़ते हैं।

इस अध्याय में, हम एक बनाते हैं Transactionवर्ग ताकि कोई ग्राहक किसी को पैसे भेज सके। ध्यान दें कि एक ग्राहक पैसे भेजने वाले या प्राप्तकर्ता दोनों हो सकते हैं। जब आप धन प्राप्त करना चाहते हैं, तो कुछ अन्य प्रेषक एक लेनदेन बनाएंगे और अपना उल्लेख करेंगेpublicइसमें पता। हम लेन-देन वर्ग की आरंभिक परिभाषा को निम्नानुसार परिभाषित करते हैं -

def __init__(self, sender, recipient, value):
   self.sender = sender
   self.recipient = recipient
   self.value = value
   self.time = datetime.datetime.now()

init विधि तीन पैरामीटर लेता है - प्रेषक public कुंजी, प्राप्तकर्ता की publicकुंजी, और भेजी जाने वाली राशि। ये अन्य तरीकों से उपयोग के लिए उदाहरण चर में संग्रहीत किए जाते हैं। इसके अतिरिक्त, हम लेनदेन के समय को संग्रहीत करने के लिए एक और चर बनाते हैं।

अगला, हम एक उपयोगिता विधि लिखते हैं जिसे कहा जाता है to_dictजो एक शब्दकोश वस्तु में सभी उपर्युक्त चार उदाहरण चर को जोड़ती है। यह सिर्फ एक ही चर के माध्यम से पूरी लेनदेन की जानकारी को सुलभ बनाने के लिए है।

जैसा कि आप पहले वाले ट्यूटोरियल से जानते हैं कि ब्लॉकचेन में पहला ब्लॉक ए है Genesisखंड मैथा। जेनेसिस ब्लॉक में ब्लॉकचैन के निर्माता द्वारा शुरू किया गया पहला लेनदेन होता है। इस व्यक्ति की पहचान को Bitcoins के मामले में गुप्त रखा जा सकता है। इसलिए जब यह पहला लेन-देन बनता है, तो निर्माता अपनी पहचान को इस रूप में भेज सकता हैGenesis। इस प्रकार, शब्दकोश बनाते समय, हम जांचते हैं कि प्रेषक क्या हैGenesisऔर यदि ऐसा है तो हम बस पहचान चर के लिए कुछ स्ट्रिंग मान असाइन करते हैं; और, हम प्रेषक की पहचान को असाइन करते हैंidentity चर।

if self.sender == "Genesis":
   identity = "Genesis"
else:
   identity = self.sender.identity

हम निम्नलिखित लाइन ऑफ़ कोड का उपयोग करके शब्दकोश का निर्माण करते हैं

return collections.OrderedDict({
   'sender': identity,
   'recipient': self.recipient,
   'value': self.value,
   'time' : self.time})

के लिए पूरा कोड to_dict विधि नीचे दी गई है -

def to_dict(self):
   if self.sender == "Genesis":
      identity = "Genesis"
   else:
      identity = self.sender.identity

   return collections.OrderedDict({
      'sender': identity,
      'recipient': self.recipient,
      'value': self.value,
      'time' : self.time})

अंत में, हम प्रेषक की निजी कुंजी का उपयोग करके इस शब्दकोश ऑब्जेक्ट पर हस्ताक्षर करेंगे। पहले की तरह, हम SHA एल्गोरिथ्म के साथ अंतर्निहित PKI का उपयोग करते हैं। हमारे ब्लॉकचेन में मुद्रण और भंडारण के लिए ASCII प्रतिनिधित्व प्राप्त करने के लिए उत्पन्न हस्ताक्षर को डिकोड किया गया है। sign_transaction विधि कोड यहाँ दिखाया गया है -

def sign_transaction(self):
   private_key = self.sender._private_key
   signer = PKCS1_v1_5.new(private_key)
   h = SHA.new(str(self.to_dict()).encode('utf8'))
   return binascii.hexlify(signer.sign(h)).decode('ascii')

अब हम इसका परीक्षण करेंगे Transaction कक्षा।

परीक्षण लेनदेन कक्षा

इस उद्देश्य के लिए, हम दो उपयोगकर्ता बनाएंगे, जिन्हें बुलाया जाएगा Dinesh तथा Ramesh। रमेश को 5 टीपीसीवाई भेजेंगे दिनेश। इसके लिए सबसे पहले हम दिनेश और रमेश नाम के क्लाइंट बनाते हैं।

Dinesh = Client()
Ramesh = Client()

याद रखें कि जब आप तुरंत ए Client वर्ग, द public andग्राहक के लिए अद्वितीय निजी कुंजी बनाई जाएगी। जैसा कि दिनेश रमेश को भुगतान भेज रहा है, उसे रमेश की सार्वजनिक कुंजी की आवश्यकता होगी जो क्लाइंट की पहचान संपत्ति का उपयोग करके प्राप्त की जाती है।

इस प्रकार, हम निम्नलिखित कोड का उपयोग करके लेनदेन का उदाहरण बनाएंगे -

t = Transaction(
   Dinesh,
   Ramesh.identity,
   5.0
)

ध्यान दें कि पहला पैरामीटर प्रेषक है, दूसरा पैरामीटर प्राप्तकर्ता की सार्वजनिक कुंजी है और तीसरा पैरामीटर स्थानांतरित होने वाली राशि है। sign_transaction विधि लेन-देन के गायन के लिए पहले पैरामीटर से प्रेषक की निजी कुंजी प्राप्त करती है।

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

signature = t.sign_transaction()
print (signature)

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

7c7e3c97629b218e9ec6e86b01f9abd8e361fd69e7d373c38420790b655b9abe3b575e343c7
13703ca1aee781acd7157a0624db3d57d7c2f1172730ee3f45af943338157f899965856f6b0
0e34db240b62673ad5a08c8e490f880b568efbc36035cae2e748f1d802d5e8e66298be826f5
c6363dc511222fb2416036ac04eb972

अब जब ग्राहक बनाने और लेन-देन करने की हमारी बुनियादी संरचना तैयार हो गई है, तो अब हमारे पास वास्तविक जीवन की स्थिति में कई ग्राहक एक साथ कई लेनदेन करेंगे।

विभिन्न ग्राहकों द्वारा किए गए लेनदेन प्रणाली में पंक्तिबद्ध हैं; खनिक इस कतार से लेनदेन उठाते हैं और इसे ब्लॉक में जोड़ते हैं। वे तब ब्लॉक को माइन करेंगे और जीतने वाले खनिक को ब्लॉकचेन में ब्लॉक को जोड़ने का विशेषाधिकार होगा और इस तरह अपने लिए कुछ पैसे कमाएंगे।

हम इस खनन प्रक्रिया का वर्णन बाद में करेंगे जब हम ब्लॉकचेन के निर्माण पर चर्चा करेंगे। इससे पहले कि हम कई लेन-देन के लिए कोड लिखें, हमें दिए गए लेनदेन की सामग्री को प्रिंट करने के लिए एक छोटी उपयोगिता फ़ंक्शन जोड़ें।

लेन-देन प्रदर्शित करना

display_transactionफ़ंक्शन लेन-देन के प्रकार के एकल पैरामीटर को स्वीकार करता है। प्राप्त लेनदेन के भीतर डिक्शनरी ऑब्जेक्ट को अस्थायी अस्थायी नाम से कॉपी किया जाता हैdict और शब्दकोश कुंजियों का उपयोग करते हुए, विभिन्न मान कंसोल पर मुद्रित होते हैं।

def display_transaction(transaction):
   #for transaction in transactions:
   dict = transaction.to_dict()
   print ("sender: " + dict['sender'])
   print ('-----')
   print ("recipient: " + dict['recipient'])
   print ('-----')
   print ("value: " + str(dict['value']))
   print ('-----')
   print ("time: " + str(dict['time']))
   print ('-----')

अगला, हम अपनी लेन-देन की वस्तुओं के भंडारण के लिए एक लेन-देन कतार को परिभाषित करते हैं।

लेन-देन कतार

एक कतार बनाने के लिए, हम एक वैश्विक घोषित करते हैं list चर कहलाता है transactions निम्नानुसार है -

transactions = []

हम इस कतार में प्रत्येक नव निर्मित लेनदेन को जोड़ देंगे। कृपया ध्यान दें कि संक्षिप्तता के लिए, हम इस ट्यूटोरियल में कतार प्रबंधन तर्क को लागू नहीं करेंगे।

कई ग्राहक बनाना

अब, हम लेनदेन बनाना शुरू करेंगे। पहले, हम चार ग्राहक बनाएंगे जो विभिन्न सेवाओं या वस्तुओं को दूसरों से प्राप्त करने के लिए एक-दूसरे को पैसा भेजेंगे।

Dinesh = Client()
Ramesh = Client()
Seema = Client()
Vijay = Client()

इस बिंदु पर, हमारे पास दिनेश, रमेश, सीमा और विजय नामक चार ग्राहक हैं। वर्तमान में हम मानते हैं कि इनमें से प्रत्येक ग्राहक लेन-देन के लिए अपनी जेब में कुछ TPCoins रखते हैं। इनमें से प्रत्येक ग्राहक की पहचान इन वस्तुओं की पहचान संपत्ति का उपयोग करके निर्दिष्ट की जाएगी।

पहला लेनदेन बनाना

अब, हम अपना पहला लेनदेन इस प्रकार करते हैं -

t1 = Transaction(
   Dinesh,
   Ramesh.identity,
   15.0
)

इस लेन-देन में दिनेश रमेश को 5 टीपीसीआईएनएस भेजता है। लेन-देन सफल होने के लिए, हमें यह सुनिश्चित करना होगा कि दिनेश के पास इस भुगतान के लिए उसके बटुए में पर्याप्त धन हो। ध्यान दें, सिस्टम में TPCoin परिसंचरण शुरू करने के लिए हमें एक जेनेसिस लेनदेन की आवश्यकता होगी। जैसे ही आप पढ़ेंगे, आप इस उत्पत्ति लेनदेन के लिए लेनदेन कोड लिखेंगे।

हम दिनेश की निजी कुंजी का उपयोग करते हुए इस लेनदेन पर हस्ताक्षर करेंगे और इसे लेन-देन कतार में इस प्रकार जोड़ेंगे -

t1.sign_transaction()
transactions.append(t1)

दिनेश द्वारा किए गए पहले लेनदेन के बाद, हम विभिन्न ग्राहकों के बीच कई और लेनदेन बनाएंगे जो हमने ऊपर बनाए थे।

अधिक लेन-देन जोड़ना

अब हम कई और लेन-देन करेंगे, प्रत्येक लेनदेन में कुछ TPCoins किसी अन्य पार्टी को दिए जाएंगे। जब कोई पैसा खर्च करता है, तो यह आवश्यक नहीं है कि उसे इस बटुए में पर्याप्त शेष राशि के लिए जांच करनी होगी। वैसे भी माइनर प्रत्येक लेन-देन को उस संतुलन के लिए मान्य कर रहा होगा जो प्रेषक के पास लेन-देन शुरू करते समय होता है।

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

निम्न कोड हमारी कतार में नौ और लेनदेन बनाता है और जोड़ता है।

t2 = Transaction(
   Dinesh,
   Seema.identity,
   6.0
)
t2.sign_transaction()
transactions.append(t2)
t3 = Transaction(
   Ramesh,
   Vijay.identity,
   2.0
)
t3.sign_transaction()
transactions.append(t3)
t4 = Transaction(
   Seema,
   Ramesh.identity,
   4.0
)
t4.sign_transaction()
transactions.append(t4)
t5 = Transaction(
   Vijay,
   Seema.identity,
   7.0
)
t5.sign_transaction()
transactions.append(t5)
t6 = Transaction(
   Ramesh,
   Seema.identity,
   3.0
)
t6.sign_transaction()
transactions.append(t6)
t7 = Transaction(
   Seema,
   Dinesh.identity,
   8.0
)
t7.sign_transaction()
transactions.append(t7)
t8 = Transaction(
   Seema,
   Ramesh.identity,
   1.0
)
t8.sign_transaction()
transactions.append(t8)
t9 = Transaction(
   Vijay,
   Dinesh.identity,
   5.0
)
t9.sign_transaction()
transactions.append(t9)
t10 = Transaction(
   Vijay,
   Ramesh.identity,
   3.0
)
t10.sign_transaction()
transactions.append(t10)

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

डंपिंग लेनदेन

एक ब्लॉकचेन प्रबंधक के रूप में, आप समय-समय पर लेनदेन कतार की सामग्री की समीक्षा करना पसंद कर सकते हैं। इस उद्देश्य के लिए, आप उपयोग कर सकते हैंdisplay_transactionफ़ंक्शन जो हमने पहले विकसित किया था। सभी लेन-देन को कतार में डंप करने के लिए, लेनदेन सूची को पुन: व्यवस्थित करें और प्रत्येक संदर्भित लेनदेन के लिए, कॉल करेंdisplay_transaction कार्य यहाँ दिखाया गया है -

for transaction in transactions:
   display_transaction (transaction)
   print ('--------------')

लेन-देन भेद के लिए एक धराशायी लाइन द्वारा अलग किया जाता है। यदि आप उपरोक्त कोड चलाते हैं, तो आपको लेन-देन सूची नीचे दिखाए अनुसार दिखाई देगी -

sender:
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c49214
4a9f463480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329e
c86794b04d773eb4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b
47e5157f8fe56c2ce3279c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311
c4d866c12d79d3fc3034563dfb0203010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e
674abe7abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8ad
d126b6e1a1308fb98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa93977
04de625d1836d3f42c7ee5683f6703259592cc24b09699376807f28fe0e00ff882974484
d805f874260dfc2d1627473b910203010001
-----
value: 15.0
-----
time: 2019-01-14 16:18:01.859915
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c49214
4a9f463480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329e
c86794b04d773eb4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b
47e5157f8fe56c2ce3279c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311
c4d866c12d79d3fc3034563dfb0203010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae14
3cbe59b3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fb
d9ee74b9e7ea12334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0
961b4f212d1fd5b5e49ae09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d0623
75799742a359b8f22c5362e5650203010001
-----
value: 6.0
-----
time: 2019-01-14 16:18:01.860966
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e
674abe7abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8ad
d126b6e1a1308fb98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa93977
04de625d1836d3f42c7ee5683f6703259592cc24b09699376807f28fe0e00ff882974484
d805f874260dfc2d1627473b910203010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100cba097c0854876
f41338c62598c658f545182cfa4acebce147aedf328181f9c4930f14498fd03c0af6b0cc
e25be99452a81df4fa30a53eddbb7bb7b203adf8764a0ccd9db6913a576d68d642d8fd47
452590137869c25d9ff83d68ebe6d616056a8425b85b52e69715b8b85ae807b84638d8f0
0e321b65e4c33acaf6469e18e30203010001
-----
value: 2.0
-----
time: 2019-01-14 16:18:01.861958
-----
--------------

संक्षिप्तता के लिए, मैंने सूची में केवल कुछ ही लेनदेन मुद्रित किए हैं। उपरोक्त कोड में, हम उत्पत्ति लेनदेन को छोड़कर पहले बहुत ही लेन-देन के साथ शुरू होने वाले सभी लेनदेन को प्रिंट करते हैं जो इस सूची में कभी नहीं जोड़ा गया था। जैसा कि लेनदेन को समय-समय पर ब्लॉक में जोड़ा जाता है, आप आम तौर पर केवल उन लेनदेन की सूची को देखने के लिए इच्छुक होंगे जो अभी तक खनन किए जा रहे हैं। उस मामले में, आपको एक उपयुक्त बनाने की आवश्यकता होगीfor लेन-देन के माध्यम से पुनरावृति करना जो अभी तक खनन नहीं किया गया है।

अब तक, आपने सीखा है कि ग्राहकों को कैसे बनाया जाए, उन्हें आपस में अनुमति दें और लंबित लेनदेन की एक कतार बनाए रखें, जिनका खनन किया जाना है। अब, इस ट्यूटोरियल का सबसे महत्वपूर्ण हिस्सा है और यह एक ब्लॉकचेन का निर्माण कर रहा है। आप इसे अगले पाठ में जानेंगे।

ब्लॉक में अलग-अलग संख्या में लेनदेन होते हैं। सादगी के लिए, हमारे मामले में हम मानेंगे कि ब्लॉक में एक निश्चित संख्या में लेनदेन शामिल हैं, जो इस मामले में तीन है। जैसा कि ब्लॉक को इन तीन लेनदेन की सूची को संग्रहीत करने की आवश्यकता है, हम एक उदाहरण चर की घोषणा करेंगेverified_transactions निम्नानुसार है -

self.verified_transactions = []

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

पिछले हैश को स्टोर करने के लिए, हम एक उदाहरण चर घोषित करते हैं -

self.previous_block_hash = ""

अंत में, हम एक और चर को घोषित करते हैं Nonce खनन प्रक्रिया के दौरान माइनर द्वारा बनाए गए नॉन को स्टोर करने के लिए।

self.Nonce = ""

की पूरी परिभाषा Block कक्षा नीचे दी गई है -

class Block:
   def __init__(self):
      self.verified_transactions = []
      self.previous_block_hash = ""
      self.Nonce = ""

जैसा कि प्रत्येक ब्लॉक को पिछले ब्लॉक के हैश के मूल्य की आवश्यकता होती है जिसे हम वैश्विक चर कहते हैं last_block_hash निम्नानुसार है -

last_block_hash = ""

अब हम ब्लॉकचेन में अपना पहला ब्लॉक बनाते हैं।

हम मानते हैं कि TPCoins के प्रवर्तक शुरू में एक ज्ञात ग्राहक को 500 TPCoins प्रदान करते हैं Dinesh। इसके लिए वह सबसे पहले दिनेश का उदाहरण देता है -

Dinesh = Client()

फिर हम एक जेनेसिस लेनदेन बनाते हैं और दिनेश के सार्वजनिक पते पर 500 टीपीसीआईएनएस भेजते हैं।

t0 = Transaction (
   "Genesis",
   Dinesh.identity,
   500.0
)

अब, हम एक उदाहरण बनाते हैं Block कक्षा और इसे बुलाओ block0

block0 = Block()

हम इनिशियलाइज़ करते हैं previous_block_hash तथा Nonce उदाहरण चर None, क्योंकि यह हमारे ब्लॉकचेन में संग्रहीत होने वाला पहला पहला लेनदेन है।

block0.previous_block_hash = None
Nonce = None

इसके बाद, हम उपरोक्त t0 लेनदेन को जोड़ेंगे verified_transactions ब्लॉक के भीतर रखी गई सूची -

block0.verified_transactions.append (t0)

इस बिंदु पर, ब्लॉक पूरी तरह से आरंभिक है और हमारे ब्लॉकचेन में जोड़ने के लिए तैयार है। हम इस उद्देश्य के लिए ब्लॉकचेन का निर्माण करेंगे। इससे पहले कि हम ब्लॉकचेन में ब्लॉक जोड़ते हैं, हम ब्लॉक को हैश करेंगे और ग्लोबल वैरिएबल में इसकी वैल्यू को स्टोर करेंगेlast_block_hashकि हमने पहले घोषित किया था। इस मूल्य का उपयोग अगले खनिक द्वारा अपने ब्लॉक में किया जाएगा।

हम ब्लॉक हैशिंग के लिए कोडिंग की निम्नलिखित दो पंक्तियों का उपयोग करते हैं और पाचन मूल्य को संग्रहीत करते हैं।

digest = hash (block0)
last_block_hash = digest

अंत में, हम एक ब्लॉकचेन बनाते हैं जैसा कि हम अगले अध्याय में देखते हैं।

ब्लॉकचेन में एक-दूसरे से जुड़े ब्लॉक की सूची होती है। संपूर्ण सूची को संग्रहीत करने के लिए, हम एक सूची चर बनाएंगे, जिसे TPCoins कहा जाता है -

TPCoins = []

हम एक उपयोगिता विधि भी लिखेंगे जिसे कहा जाता है dump_blockchainपूरे ब्लॉकचेन की सामग्री को डंप करने के लिए। हम पहले ब्लॉकचेन की लंबाई को प्रिंट करते हैं ताकि हमें पता चले कि ब्लॉकचेन में वर्तमान में कितने ब्लॉक मौजूद हैं।

def dump_blockchain (self):
   print ("Number of blocks in the chain: " + str(len (self)))

ध्यान दें कि जैसे-जैसे समय बीतता है, ब्लॉकचेन में ब्लॉकों की संख्या मुद्रण के लिए असाधारण रूप से अधिक हो जाएगी। इस प्रकार, जब आप ब्लॉकचेन की सामग्री प्रिंट करते हैं, तो आपको उस सीमा पर निर्णय लेना पड़ सकता है जिसे आप जांचना चाहते हैं। नीचे दिए गए कोड में, हमने पूरे ब्लॉकचेन को मुद्रित किया है क्योंकि हम वर्तमान डेमो में बहुत सारे ब्लॉक नहीं जोड़ रहे हैं।

श्रृंखला के माध्यम से पुनरावृत्ति करने के लिए, हम एक सेट करते हैं for पाश इस प्रकार है -

for x in range (len(TPCoins)):
   block_temp = TPCoins[x]

प्रत्येक संदर्भित ब्लॉक को अस्थायी अस्थायी नाम से कॉपी किया जाता है block_temp

हम प्रत्येक ब्लॉक के लिए हेडिंग के रूप में ब्लॉक नंबर प्रिंट करते हैं। ध्यान दें कि संख्याएं शून्य से शुरू होंगी, पहला ब्लॉक एक जीनसिस ब्लॉक है जिसे शून्य गिना जाता है।

print ("block # " + str(x))

प्रत्येक ब्लॉक के भीतर, हमने एक वेरिएबल में तीन लेनदेन की सूची (जीनस ब्लॉक को छोड़कर) संग्रहीत की है verified_transactions। हम इस सूची को एक में बदल देते हैंfor लूप और प्रत्येक प्राप्त आइटम के लिए, हम कॉल करते हैं display_transaction लेनदेन विवरण प्रदर्शित करने के लिए कार्य करते हैं।

for transaction in block_temp.verified_transactions:
   display_transaction (transaction)

संपूर्ण फ़ंक्शन की परिभाषा नीचे दी गई है -

def dump_blockchain (self):
   print ("Number of blocks in the chain: " + str(len (self)))
   for x in range (len(TPCoins)):
      block_temp = TPCoins[x]
      print ("block # " + str(x))
      for transaction in block_temp.verified_transactions:
         display_transaction (transaction)
         print ('--------------')
      print ('=====================================')

ध्यान दें कि यहां हमने विभाजकों को कोड में उपयुक्त बिंदुओं पर सम्मिलित किया है ताकि इसके भीतर ब्लॉक और लेनदेन का सीमांकन किया जा सके।

जैसा कि हमने अब स्टोरिंग ब्लॉक के लिए एक ब्लॉकचेन बनाया है, हमारा अगला काम ब्लॉक बनाना है और इसे ब्लॉकचेन में जोड़ना शुरू करना है। इस उद्देश्य के लिए, हम एक उत्पत्ति खंड जोड़ेंगे जो आपने पहले चरण में बनाया है।

ब्लॉकचैन में एक ब्लॉक जोड़ने से हमारे लिए बनाया ब्लॉक को जोड़ना शामिल है TPCoins सूची।

TPCoins.append (block0)

ध्यान दें कि सिस्टम के बाकी ब्लॉकों के विपरीत, जेनेसिस ब्लॉक में केवल एक लेनदेन होता है जो टीपीसी सिस्टम के प्रवर्तक द्वारा शुरू किया जाता है। अब, आप हमारे वैश्विक फ़ंक्शन को कॉल करके ब्लॉकचेन की सामग्री को डंप करेंगेdump_blockchain -

dump_blockchain(TPCoins)

जब आप इस फ़ंक्शन को निष्पादित करते हैं, तो आप निम्न आउटपुट देखेंगे -

Number of blocks in the chain: 1
block # 0
sender: Genesis
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100ed272b52ccb539
e2cd779c6cc10ed1dfadf5d97c6ab6de90ed0372b2655626fb79f62d0e01081c163b0864
cc68d426bbe9438e8566303bb77414d4bfcaa3468ab7febac099294de10273a816f7047d
4087b4bafa11f141544d48e2f10b842cab91faf33153900c7bf6c08c9e47a7df8aa7e60d
c9e0798fb2ba3484bbdad2e4430203010001
-----
value: 500.0
-----
time: 2019-01-14 16:18:02.042739
-----
--------------
=====================================

इस बिंदु पर ब्लॉकचेन सिस्टम उपयोग करने के लिए तैयार है। अब हम इच्छुक ग्राहकों को खनन कार्यशीलता प्रदान करके खनिक बनने में सक्षम बनाएंगे।

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

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

हम एक उपयोगिता फ़ंक्शन लिखेंगे जिसे कहा जाता है 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" से शुरू होगा, और निश्चित रूप से, इसे शायद अधिक संख्या में पुनरावृत्तियों की आवश्यकता होगी। जैसा कि आप देख सकते हैं, अधिक प्रसंस्करण शक्ति वाला एक खनिक पहले दिए गए संदेश को माइन करने में सक्षम होगा। इस तरह से खनिक अपना राजस्व अर्जित करने के लिए एक-दूसरे से प्रतिस्पर्धा करते हैं।

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

प्रत्येक खनिक एक पहले से बनाए गए लेन-देन पूल से लेनदेन उठाएगा। पहले से खनन किए गए संदेशों की संख्या को ट्रैक करने के लिए, हमें एक वैश्विक चर बनाना होगा -

last_transaction_index = 0

अब हम अपने पहले खनिक को ब्लॉकचेन में ब्लॉक जोड़ेंगे।

पहला ब्लॉक जोड़ना

एक नया ब्लॉक जोड़ने के लिए, हम सबसे पहले एक उदाहरण बनाते हैं Block कक्षा।

block = Block()

हम कतार से शीर्ष 3 लेनदेन उठाते हैं -

for i in range(3):
   temp_transaction = transactions[last_transaction_index]
   # validate transaction

लेनदेन को ब्लॉक में जोड़ने से पहले खनिक लेनदेन की वैधता को सत्यापित करेगा। लेन-देन की वैधता को परीक्षणकर्ता द्वारा सत्यापित किया जाता है कि प्रेषक द्वारा सार्वजनिक रूप से प्रेषित की गई हैश के खिलाफ उपलब्ध कराए गए हैश के साथ सेंडर की सार्वजनिक कुंजी का उपयोग करके। इसके अलावा, माइनर सत्यापित करेगा कि प्रेषक के पास वर्तमान लेनदेन के भुगतान के लिए पर्याप्त शेष है।

संक्षिप्तता के लिए, हमने इस कार्यक्षमता को ट्यूटोरियल में शामिल नहीं किया है। लेन-देन मान्य होने के बाद, हम इसे जोड़ते हैंverified_transactions में सूची block उदाहरण।

block.verified_transactions.append (temp_transaction)

हम अंतिम लेन-देन सूचकांक बढ़ाते हैं ताकि अगले खनिक कतार में बाद में लेनदेन करेंगे।

last_transaction_index += 1

हम ब्लॉक में ठीक तीन लेन-देन जोड़ते हैं। एक बार यह हो जाने के बाद, हम बाकी के इंस्टेंस वेरिएबल को इनिशियलाइज़ करेंगेBlockकक्षा। हम पहले अंतिम ब्लॉक का हैश जोड़ते हैं।

block.previous_block_hash = last_block_hash

अगला, हम 2 के कठिनाई स्तर के साथ ब्लॉक को खदान करते हैं।

block.Nonce = mine (block, 2)

ध्यान दें कि पहले पैरामीटर mineफंक्शन एक बाइनरी ऑब्जेक्ट है। अब हम पूरे ब्लॉक को हैश करते हैं और उस पर एक पाचन बनाते हैं।

digest = hash (block)

अंत में, हम निर्मित ब्लॉक को ब्लॉकचेन में जोड़ते हैं और वैश्विक चर को फिर से शुरू करते हैं last_block_hash अगले ब्लॉक में उपयोग के लिए।

ब्लॉक को जोड़ने का पूरा कोड नीचे दिखाया गया है -

block = Block()
for i in range(3):
   temp_transaction = transactions[last_transaction_index]
   # validate transaction
   # if valid
   block.verified_transactions.append (temp_transaction)
   last_transaction_index += 1

block.previous_block_hash = last_block_hash
block.Nonce = mine (block, 2)
digest = hash (block)
TPCoins.append (block)
last_block_hash = digest

अधिक ब्लॉक जोड़ना

अब हम अपने ब्लॉकचेन में दो और ब्लॉक जोड़ेंगे। अगले दो ब्लॉक जोड़ने का कोड नीचे दिया गया है -

# Miner 2 adds a block
block = Block()

for i in range(3):
   temp_transaction = transactions[last_transaction_index]
   # validate transaction
   # if valid
   block.verified_transactions.append (temp_transaction)
   last_transaction_index += 1
block.previous_block_hash = last_block_hash
block.Nonce = mine (block, 2)digest = hash (block)
TPCoins.append (block)last_block_hash = digest
# Miner 3 adds a block
block = Block()

for i in range(3):
   temp_transaction = transactions[last_transaction_index]
   #display_transaction (temp_transaction)
   # validate transaction
   # if valid
   block.verified_transactions.append (temp_transaction)
   last_transaction_index += 1

block.previous_block_hash = last_block_hash
block.Nonce = mine (block, 2)
digest = hash (block)

TPCoins.append (block)
last_block_hash = digest

जब आप इन दो ब्लॉकों को जोड़ते हैं, तो आप गैर-खोजने के लिए पुनरावृत्तियों की संख्या भी देखेंगे। इस बिंदु पर, हमारे ब्लॉकचेन में जीनस ब्लॉक सहित पूरी तरह से 4 ब्लॉक शामिल हैं।

डंपिंग एंट्री ब्लॉकचेन

आप निम्नलिखित विवरण का उपयोग करके पूरे ब्लॉकचेन की सामग्री को सत्यापित कर सकते हैं -

dump_blockchain(TPCoins)

आप नीचे दिखाए गए के समान आउटपुट देखेंगे -

Number of blocks in the chain: 4
block # 0
sender: Genesis
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100ed272b52ccb539e2cd779
c6cc10ed1dfadf5d97c6ab6de90ed0372b2655626fb79f62d0e01081c163b0864cc68d426bbe943
8e8566303bb77414d4bfcaa3468ab7febac099294de10273a816f7047d4087b4bafa11f141544d4
8e2f10b842cab91faf33153900c7bf6c08c9e47a7df8aa7e60dc9e0798fb2ba3484bbdad2e44302
03010001
-----
value: 500.0
-----
time: 2019-01-14 16:18:02.042739
-----
--------------
=====================================
block # 1
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c492144a9f463
480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329ec86794b04d773e
b4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b47e5157f8fe56c2ce3279
c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311c4d866c12d79d3fc3034563dfb02
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e674abe7
abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8add126b6e1a1308f
b98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa9397704de625d1836d3f42c7ee
5683f6703259592cc24b09699376807f28fe0e00ff882974484d805f874260dfc2d1627473b9102
03010001
-----
value: 15.0
-----
time: 2019-01-14 16:18:01.859915
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c492144a9f463
480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329ec86794b04d773e
b4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b47e5157f8fe56c2ce3279
c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311c4d866c12d79d3fc3034563dfb02
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
value: 6.0
-----
time: 2019-01-14 16:18:01.860966
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e674abe7
abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8add126b6e1a1308f
b98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa9397704de625d1836d3f42c7ee
5683f6703259592cc24b09699376807f28fe0e00ff882974484d805f874260dfc2d1627473b9102
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100cba097c0854876f41338c
62598c658f545182cfa4acebce147aedf328181f9c4930f14498fd03c0af6b0cce25be99452a81d
f4fa30a53eddbb7bb7b203adf8764a0ccd9db6913a576d68d642d8fd47452590137869c25d9ff83
d68ebe6d616056a8425b85b52e69715b8b85ae807b84638d8f00e321b65e4c33acaf6469e18e302
03010001
-----
value: 2.0
-----
time: 2019-01-14 16:18:01.861958
-----
--------------
=====================================
block # 2
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e674abe7
abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8add126b6e1a1308f
b98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa9397704de625d1836d3f42c7ee
5683f6703259592cc24b09699376807f28fe0e00ff882974484d805f874260dfc2d1627473b9102
03010001
-----
value: 4.0
-----
time: 2019-01-14 16:18:01.862946
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100cba097c0854876f41338c
62598c658f545182cfa4acebce147aedf328181f9c4930f14498fd03c0af6b0cce25be99452a81d
f4fa30a53eddbb7bb7b203adf8764a0ccd9db6913a576d68d642d8fd47452590137869c25d9ff83
d68ebe6d616056a8425b85b52e69715b8b85ae807b84638d8f00e321b65e4c33acaf6469e18e302
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
value: 7.0
-----
time: 2019-01-14 16:18:01.863932
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e674abe7
abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8add126b6e1a1308f
b98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa9397704de625d1836d3f42c7ee
5683f6703259592cc24b09699376807f28fe0e00ff882974484d805f874260dfc2d1627473b9102
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
value: 3.0
-----
time: 2019-01-14 16:18:01.865099
-----
--------------
=====================================
block # 3
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c492144a9f463
480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329ec86794b04d773e
b4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b47e5157f8fe56c2ce3279
c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311c4d866c12d79d3fc3034563dfb02
03010001
-----
value: 8.0
-----
time: 2019-01-14 16:18:01.866219
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100a070c82b34ae143cbe59b
3a2afde7186e9d5bc274955d8112d87a00256a35369acc4d0edfe65e8f9dc93fbd9ee74b9e7ea12
334da38c8c9900e6ced1c4ce93f86e06611e656521a1eab561892b7db0961b4f212d1fd5b5e49ae
09cf8c603a068f9b723aa8a651032ff6f24e5de00387e4d062375799742a359b8f22c5362e56502
03010001
-----
recipient:
30819f300d06092a864886f70d010101050003818d0030818902818100be93b516b28c6e674abe7
abdb11ce0fdf5bb728b75216b73f37a6432e4b402b3ad8139b8c0ba541a72c8add126b6e1a1308f
b98b727beb63c6060356bb177bb7d54b54dbe87aee7353d0a6baa9397704de625d1836d3f42c7ee
5683f6703259592cc24b09699376807f28fe0e00ff882974484d805f874260dfc2d1627473b9102
03010001
-----
value: 1.0
-----
time: 2019-01-14 16:18:01.867223
-----
--------------
sender:
30819f300d06092a864886f70d010101050003818d0030818902818100cba097c0854876f41338c
62598c658f545182cfa4acebce147aedf328181f9c4930f14498fd03c0af6b0cce25be99452a81d
f4fa30a53eddbb7bb7b203adf8764a0ccd9db6913a576d68d642d8fd47452590137869c25d9ff83
d68ebe6d616056a8425b85b52e69715b8b85ae807b84638d8f00e321b65e4c33acaf6469e18e302
03010001
-----
recipient: 
30819f300d06092a864886f70d010101050003818d0030818902818100bb064c99c492144a9f463
480273aba93ac1db1f0da3cb9f3c1f9d058cf499fd8e54d244da0a8dd6ddd329ec86794b04d773e
b4841c9f935ea4d9ccc2821c7a1082d23b6c928d59863407f52fa05d8b47e5157f8fe56c2ce3279
c657f9c6a80500073b0be8093f748aef667c03e64f04f84d311c4d866c12d79d3fc3034563dfb02
03010001
-----
value: 5.0
-----
time: 2019-01-14 16:18:01.868241
-----
--------------
=====================================

इस ट्यूटोरियल में, हमने सीखा कि पायथन में ब्लॉकचेन प्रोजेक्ट कैसे बनाया जाए। ऐसे कई क्षेत्र हैं जहां आपको इस परियोजना में और अधिक कार्यक्षमता जोड़ने की आवश्यकता है।

उदाहरण के लिए, आपको लेन-देन कतार के प्रबंधन के लिए फ़ंक्शन लिखना होगा। लेन-देन के बाद और खनन किए गए ब्लॉक को सिस्टम द्वारा स्वीकार किया जाता है, उन्हें किसी भी अधिक संग्रहीत करने की आवश्यकता नहीं है।

इसके अलावा, खनिक निश्चित रूप से उच्चतम शुल्क के साथ लेनदेन करना पसंद करेंगे। उसी समय, आपको यह सुनिश्चित करना होगा कि कम या बिना किसी शुल्क के लेनदेन हमेशा के लिए नहीं होगा।

कतार को प्रबंधित करने के लिए आपको एल्गोरिदम विकसित करने की आवश्यकता होगी। साथ ही, वर्तमान ट्यूटोरियल में क्लाइंट इंटरफ़ेस कोड शामिल नहीं है। आपको इसे सामान्य ग्राहकों और खनिक दोनों के लिए विकसित करना होगा। पूर्ण विकसित ब्लॉकचेन परियोजना कोड की कई और लाइनों में चलेगी और इस ट्यूटोरियल के दायरे से बाहर है। इच्छुक पाठक आगे के अध्ययन के लिए बिटकॉइन स्रोत डाउनलोड कर सकते हैं ।

निष्कर्ष

यह कुरकुरा ट्यूटोरियल आपको अपनी ब्लॉकचेन परियोजना बनाने पर शुरू करना चाहिए।

पूर्ण विकसित ब्लॉकचेन परियोजना विकास के लिए, आप बिटकॉइन स्रोत से अधिक सीख सकते हैं ।

बड़ी व्यावसायिक या गैर-वाणिज्यिक परियोजनाओं के लिए, आप Ethereum का उपयोग करने पर विचार कर सकते हैं - ब्लॉकचेन ऐप प्लेटफॉर्म का उपयोग करने के लिए तैयार।