अपनी खुद की ब्लॉकचेन बनाएं

चरण 1 - एक ब्लॉक और उसका फिंगरप्रिंट

एक ब्लॉक में कुछ डेटा (लेन-देन), पिछले ब्लॉक का एक लिंक और एक "नॉन्स" (एक संख्या जिसे हम बदल सकते हैं) रखता है। इसकी पहचान इसकी सभी सामग्रियों का SHA-256 हैश है - एक वर्ण बदलें और हैश पूरी तरह से बदल जाता है। वह हैश ब्लॉक का छेड़छाड़-स्पष्ट फ़िंगरप्रिंट है।

import hashlib, json, time

class Block:
    def __init__(self, index, transactions, previous_hash, nonce=0):
        self.index = index
        self.timestamp = time.time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce

    def hash(self):
        # A block's fingerprint = SHA-256 of all its contents.
        payload = json.dumps({
            "index": self.index,
            "timestamp": self.timestamp,
            "transactions": self.transactions,
            "previous_hash": self.previous_hash,
            "nonce": self.nonce,
        }, sort_keys=True).encode()
        return hashlib.sha256(payload).hexdigest()

चरण 2 - खनन (कार्य का प्रमाण)

खनन का अर्थ है एक हैश ढूंढना जो एक नियम को पूरा करता है - यहां, शून्य की एक निर्धारित संख्या से शुरू होता है। कोई फार्मूला नहीं है; जब तक हैश फिट नहीं हो जाता तब तक आप नॉन्स को बलपूर्वक लागू करते हैं। किसी समाधान की जाँच करना तुरंत होता है, लेकिन उसे ढूंढने में काम लगता है। वह विषमता कार्य के प्रमाण का हृदय है।

DIFFICULTY = 4  # require this many leading zeros

def mine(block):
    # Proof of Work: keep changing the nonce until the hash
    # starts with DIFFICULTY zeros. There is no shortcut —
    # you just have to guess, which is what costs energy.
    target = "0" * DIFFICULTY
    while not block.hash().startswith(target):
        block.nonce += 1
    return block.hash()

चरण 3 - ब्लॉकों को जंजीर से बांधना

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

class Blockchain:
    def __init__(self):
        # The genesis block — the very first, hard-coded block.
        genesis = Block(0, [{"note": "genesis"}], "0")
        mine(genesis)
        self.chain = [genesis]

    def add_block(self, transactions):
        prev = self.chain[-1]
        block = Block(len(self.chain), transactions, prev.hash())
        mine(block)            # do the work
        self.chain.append(block)
        return block

चरण 4 - श्रृंखला को मान्य करना

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

def is_valid(chain):
    for i in range(1, len(chain)):
        current, previous = chain[i], chain[i - 1]
        # 1) Each block must point to the real hash of the one before it.
        if current.previous_hash != previous.hash():
            return False
        # 2) Each block must satisfy the proof-of-work rule.
        if not current.hash().startswith("0" * DIFFICULTY):
            return False
    return True

चरण 5 - इसे चलाएँ और धोखा देने का प्रयास करें

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

bc = Blockchain()
bc.add_block([{"from": "Alice", "to": "Bob", "amount": 5}])
bc.add_block([{"from": "Bob", "to": "Carol", "amount": 2}])

print("Chain valid?", is_valid(bc.chain))   # True

# Now try to cheat: tamper with an old transaction.
bc.chain[1].transactions[0]["amount"] = 5000
print("Chain valid?", is_valid(bc.chain))   # False — tampering is caught!

असली बिटकॉइन क्या जोड़ता है

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

अक्सर पूछे जाने वाले प्रश्नों

सीखते रखना