R में कोड करके ब्लॉकचेन को समझें

आजकल हर कोई क्रिप्टोकरेंसी की बात कर रहा है — बिटकॉइन की चर्चा के कारण। यह जानने से कहीं ज्यादा रोचक कि बिटकॉइन में बुलबुला है या नहीं, यह प्रश्न है कि यह तकनीक असल में काम कैसे करती है और इसके क्या-क्या उपयोग हो सकते हैं। बिटकॉइन की कहानी 2008 के एक श्वेतपत्र "Bitcoin: A Peer-to-Peer Electronic Cash System" से शुरू हुई। इस पेपर में सतोशी नाकामोतो (अब भी इस बात पर बहस जारी है कि सतोशी वास्तव में कौन हैं) नामक लेखक ने एक नई, क्रांतिकारी तकनीक और विचार पेश किया: एक विकेंद्रीकृत इलेक्ट्रॉनिक मुद्रा जो ब्लॉकचेन नाम की चीज़ पर चलती है। यह विचार यहीं से फैला और आज इसे कई अन्य क्षेत्रों में भी लागू किया जा सकता है।

मुझे पहली बार ब्लॉकचेन से परिचय ऑक्सफ़ोर्ड के BlockchainSociety की एक बैठक में हुआ। वहां सभी लोग इस नई तकनीक की संभावनाओं को लेकर बहुत उत्साहित दिख रहे थे। और सच कहें तो यह आकर्षक लगता है: लेनदेन, अनुबंधों या आपकी पसंद के किसी भी डेटा (उदाहरण के लिए, हैक-प्रूफ वोटिंग मशीनें) का एक विकेंद्रीकृत, छेड़छाड़-रोधी डेटाबेस। क्रिप्टो समुदाय के लिए ब्लॉकचेन का वादा यह है कि यह भरोसे की परिभाषा को बदल कर पूरी उद्योगों में बदलाव ला देगा — ताकि हमें बैंकों या वकीलों जैसे तीसरे पक्ष की जरूरत न रहे; हमें चाहिए तो सिर्फ क्रिप्टोग्राफी की ताकत।

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

ब्लॉकचेन क्या है?

मान लीजिए आपका लक्ष्य कुछ डेटा को सुरक्षित तरीके से सहेजना है। इसके लिए आप पहले डेटा को एक कंटेनर — जिसे आप ब्लॉक कहते हैं — में रखते हैं। बिटकॉइन के मामले में, प्रत्येक ब्लॉक में कई वित्तीय लेनदेन होते हैं। जब नए लेनदेन (या नया डेटा) आते हैं तो एक नया ब्लॉक बनाया जाता है और उसे पिछले ब्लॉकों के साथ जोड़कर एक श्रृंखला — ब्लॉकचेन — बनाई जाती है।

आइए देखें कि ब्लॉकचेन क्रिप्टोग्राफी का उपयोग करके लगभग हैक-प्रूफ कैसे बनते हैं।

1. ब्लॉक्स

    block_example <- list(index = 1,
                     timestamp = "2018-01-05 17.00 MST",
                     data = "some data",
                     previous_hash = 0,
                     proof = 9,
                     new_hash = NULL)
संचालित द्वारा

ब्लॉकचेन बनाना — यानी डेटा वाले अलग-अलग कंटेनरों को एक साथ जोड़ना — शुरू करने से पहले, आपको दो और अवधारणाओं को समझना होगा: हैशिंग और प्रूफ-ऑफ-वर्क एल्गोरिदम।

2. हैश

एक हैश, ब्लॉक को श्रृंखला के अन्य ब्लॉकों से जोड़कर उसकी अखंडता सुनिश्चित करने में मदद करता है। हैश फंक्शन किसी इनपुट को लेकर आपको एक अद्वितीय, एन्क्रिप्टेड आउटपुट देता है। उदाहरण के लिए: आप अपनी मित्र को यह पहेली देते हैं — "बेहतर सांख्यिकी प्रोग्राम कौन-सा है: Stata या R?" — और आप उसे सही उत्तर का हैश देते हैं: "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"। अब वह सिर्फ अपने उत्तर को हैश-फंक्शन (आपके मामले में SHA256 एल्गोरिदम) में डालकर खुद जांच सकती है कि उसका उत्तर सही है या नहीं:

    library("digest")

    digest("Stata" ,"sha256") # first try
संचालित द्वारा

    ## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"
संचालित द्वारा

    digest("R", "sha256") # second try
संचालित द्वारा

    ## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"
संचालित द्वारा

यह आपकी कैसे मदद करता है?

इस मामले में, आप हैश फंक्शन में ब्लॉक की जानकारी (index, timestamp, data) के साथ-साथ पिछले ब्लॉक का हैश भी इनपुट करते हैं। इसका मतलब है कि आप वैध हैश तभी निकाल सकते हैं जब आपको पिछले ब्लॉक का हैश पता हो, जो अपने से पहले वाले ब्लॉक के हैश से बना होता है, और यह क्रम ऐसे ही चलता रहता है। इससे आपको ब्लॉकों की एक अपरिवर्तनीय, अनुक्रमिक श्रृंखला मिलती है। यदि आप बाद में किसी एक ब्लॉक में बदलाव करेंगे तो आपको उसके बाद आने वाले सभी ब्लॉकों के हैश दोबारा से निकालने होंगे।

    #Function that creates a hashed "block"
    hash_block <- function(block){
      block$new_hash <- digest(c(block$index,
                                 block$timestamp,
                                 block$data,
                                 block$previous_hash), "sha256")
      return(block)
    }
संचालित द्वारा

3. प्रूफ-ऑफ-वर्क

यदि ब्लॉकचेन में बहुत सारी जानकारी सहेजनी है, तो आपको बहुत से नए ब्लॉक्स बनाने होंगे। कई स्थितियों में, आप यह नियंत्रित करना चाहते हैं कि कितने नए ब्लॉक्स बनें। उदाहरण के लिए, क्रिप्टोकरेंसी के मामले में, यदि हर सेकंड अनंत संख्या में सिक्के बनाए जा सकें, तो सिक्कों की कीमत घट जाएगी।

इसीलिए, हम एक तथाकथित "प्रूफ-ऑफ-वर्क" (PoW) एल्गोरिदम जोड़ते हैं जो नया ब्लॉक बनाने की कठिनाई को नियंत्रित करता है। "प्रूफ" का मतलब है कि कंप्यूटर ने एक निश्चित मात्रा में काम किया है। व्यवहार में लक्ष्य ऐसा कार्य बनाना है जिसे बनाना कठिन हो लेकिन सत्यापित करना आसान। मैं निम्नलिखित "कार्य" को PoW के रूप में इस्तेमाल करूंगा: अगला ऐसा संख्या ढूंढें जो 99 से भी विभाजित हो और पिछले ब्लॉक की प्रूफ-संख्या से भी विभाजित हो।

    ### Simple Proof of Work Alogrithm
    proof_of_work <- function(last_proof){
      proof <- last_proof + 1

      # Increment the proof number until a number is found that is divisable by 99 and by the proof of the previous block
      while (!(proof %% 99 == 0 & proof %% last_proof == 0 )){
        proof <- proof + 1
      }

      return(proof)
    }
संचालित द्वारा

Bitcoin या Ethereum जैसे ब्लॉकचेन में नए ब्लॉक्स बनाने का काम तथाकथित माइनर्स करते हैं। जब एक नया ब्लॉक बनना होता है, तो नेटवर्क में एक कम्प्यूटेशनल समस्या भेजी जाती है। जो माइनर सबसे पहले PoW समस्या को हल करता है, वह नया ब्लॉक बनाता है और बिटकॉइन में इनाम पाता है (यही तरीके से नए बिटकॉइन बनते हैं)। सही प्रूफ खोजने की यह "लॉटरी" सुनिश्चित करती है कि नए ब्लॉक्स बनाने की शक्ति विकेंद्रीकृत रहे। जब कोई नया ब्लॉक माइन होता है, तो उसे सभी तक भेजा जाता है ताकि नेटवर्क के हर नोड के पास नवीनतम ब्लॉकचेन की प्रति हो। नेटवर्क में सबसे लंबी ब्लॉकचेन (जिसमें "सबसे ज्यादा काम लगाया गया") को ब्लॉकचेन का वैध संस्करण मानने के विचार को "विकेंद्रीकृत सर्वसम्मति" कहा जाता है।

Bitcoin के मामले में PoW समस्या में ऐसी संख्याएं ढूंढनी होती हैं जो एक निश्चित संख्या में अग्रणी शून्यों वाले हैश बनाएं (इसकी सबसे अच्छी व्याख्या मुझे Savjee के इस वीडियो में मिली)। नेटवर्क में कम्प्यूटेशनल गति बढ़ने और माइनर्स की संख्या बदलने को ध्यान में रखते हुए PoW की कठिनाई को समायोजित किया जा सकता है ताकि नया ब्लॉक बनाने का समय लगभग दस मिनट के आसपास स्थिर रहे।

4. नए ब्लॉक्स जोड़ना

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

    #A function that takes the previous block and normally some data (in our case the data is a string indicating which block in the chain it is)
    gen_new_block <- function(previous_block){

      #Proof-of-Work
      new_proof <- proof_of_work(previous_block$proof)

      #Create new Block
      new_block <- list(index = previous_block$index + 1,
                        timestamp = Sys.time(),
                        data = paste0("this is block ", previous_block$index +1),
                        previous_hash = previous_block$new_hash,
                        proof = new_proof)

      #Hash the new Block
      new_block_hashed <- hash_block(new_block)

      return(new_block_hashed)
    }
संचालित द्वारा

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

    # Define Genesis Block (index 1 and arbitrary previous hash)
    block_genesis <-  list(index = 1,
                           timestamp = Sys.time(),
                           data = "Genesis Block",
                           previous_hash = "0",
                           proof = 1)
संचालित द्वारा

5. ब्लॉकचेन बनाना

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

    blockchain <- list(block_genesis)
    previous_block <- blockchain[[1]]

      # How many blocks should we add to the chain after the genesis block
      num_of_blocks_to_add <- 5

      # Add blocks to the chain
      for (i in 1: num_of_blocks_to_add){
        block_to_add <- gen_new_block(previous_block) 
        blockchain[i+1] <- list(block_to_add)
        previous_block <- block_to_add

        print(cat(paste0("Block ", block_to_add$index, " has been added", "\n",
                   "\t", "Proof: ", block_to_add$proof, "\n",
                   "\t", "Hash: ", block_to_add$new_hash)))
      }
संचालित द्वारा

    ## Block 2 has been added
    ##  Proof: 99
    ##  Hash: 7d3dfbb58b410838769f6080dbc62a44a4c5d411a41048c4e597d26dccd1cd38NULL
    ## Block 3 has been added
    ##  Proof: 198
    ##  Hash: 4f8bdd79d751f9e9829c14c52a737f257285b61e54b29531dd59bf1a530f1097NULL
    ## Block 4 has been added
    ##  Proof: 396
    ##  Hash: 512b877c4ff92605d9fe10ac73ced20f748742964f306c211c4691f15425a26eNULL
    ## Block 5 has been added
    ##  Proof: 792
    ##  Hash: a3baaa025186c5bcb2238a888bc65e705ffe73c17dc5c8f26ee337fd62867993NULL
    ## Block 6 has been added
    ##  Proof: 1584
    ##  Hash: d12c3f54c14f3287a9f31ab542271197ba6a658cee561a9289819dd563fe4991NULL
संचालित द्वारा

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

Bitcoin जैसी क्रिप्टोकरेंसी के लिए यह समस्या होगी, क्योंकि नए ब्लॉक बनाने का समय कमोबेश स्थिर होना चाहिए (Bitcoin में लगभग 10 मिनट)। इसलिए, नेटवर्क में कम्प्यूटेशनल गति बढ़ने और माइनर्स की संख्या बदलने के अनुसार PoW की कठिनाई को लगातार समायोजित करना पड़ता है।

अंततः, आपकी श्रृंखला में एक ब्लॉक कुछ इस तरह दिखता है:

    blockchain[[5]]
संचालित द्वारा

    ## $index
    ## [1] 5
    ## 
    ## $timestamp
    ## [1] "2018-02-08 12:02:56 GMT"
    ## 
    ## $data
    ## [1] "this is block 5"
    ## 
    ## $previous_hash
    ## [1] "26cdc16a4560df5fa2fd521dbca22670e2475c35d3dd90781872bee98a164eef"
    ## 
    ## $proof
    ## [1] 792
    ## 
    ## $new_hash
    ## [1] "2eef25bf0bc4ee81e8c7cd1dfda65855b4ba32aba218d8c525a03a72b3454d74"
संचालित द्वारा

समापन

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

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

यह छोटा परिचय Gerald Nash के ब्लॉग पोस्ट पर आधारित है, जिन्होंने Python में "सबसे छोटा ब्लॉकचेन" लागू किया। मैंने इसे R में लागू किया और Daniel van Flymen के PoW कार्यान्वयन को जोड़ा।

ब्लॉकचेन विषय में गहराई से जाने के लिए मैं सतोशी नाकामोतो का उत्कृष्ट, मौलिक बिटकॉइन पर श्वेतपत्र और BigData Doc का ब्लॉग पोस्ट सुझाता/सुझाती हूं।

यदि इस ब्लॉग पोस्ट पर आपके कोई विचार या प्रतिक्रियाएं हों, तो मुझसे Twitter पर बेझिझक संपर्क करें: आप मुझे @jj_mllr पर पा सकते हैं या @CorrelAid देखें — युवा डेटा विश्लेषकों का एक नेटवर्क जो अधिक समावेशी, एकीकृत और नवाचारी डेटा विश्लेषण के जरिये दुनिया बदलना चाहता है।