ඔබේම Blockchain ගොඩනඟන්න

පියවර 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 - එය ධාවනය කර වංචා කිරීමට උත්සාහ කරන්න

දැන් බ්ලොක් කිහිපයක් එකතු කර පැරණි ගනුදෙනුවකට හානි කරන්න. ඔබ අතීත දත්ත වෙනස් කරන මොහොතේ, එම බ්ලොක් එකේ හැෂ් තවදුරටත් මීළඟ බ්ලොක් එක බලාපොරොත්තු වන දෙයට නොගැලපේ - සහ වලංගු කිරීම ක්ෂණිකව අසත්‍යය ලබා දෙයි. මෙය කුඩා ස්වරූපයෙන්, ඔබට Bitcoin හි ඉතිහාසය නිහඬව නැවත ලිවිය නොහැක.

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!

සැබෑ Bitcoin එකතු කරන දේ

අපේ සෙල්ලම් දාමය ඇටසැකිල්ල උගන්වයි. Real Bitcoin ගෝලීය peer-to-peer nodes ජාලයක්, කාසි වියදම් කළ හැක්කේ කාටද යන්න සනාථ කරන ඩිජිටල් අත්සන්, ස්වයංක්‍රීය දුෂ්කරතා ගැලපීම, UTXO ආකෘතිය, ත්‍යාග සහ අඩක් අවහිර කිරීම සහ ආගන්තුකයන්ට විශ්වාසයකින් තොරව එකඟ වීමට ඉඩ සලසන එකඟතා නීති එක් කරයි. පහත අපගේ පැහැදිලි කරන්නන් තුළ එක් එක් ගවේෂණය කරන්න.

නිතර අසන ප්රශ්න

දිගටම ඉගෙන ගන්න