Bina Blockchain Anda Sendiri

Langkah 1 — Blok dan cap jarinya

Blok menyimpan beberapa data (urus niaga), pautan ke blok sebelumnya dan "nonce" (nombor yang boleh kita ubah). Identitinya ialah cincang SHA-256 bagi semua kandungannya — tukar satu aksara dan cincang berubah sepenuhnya. Cincang itu ialah cap jari yang boleh diganggu gugat.

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()

Langkah 2 — Perlombongan (Bukti Kerja)

Perlombongan bermaksud mencari cincang yang memenuhi peraturan — di sini, bermula dengan bilangan sifar yang ditetapkan. Tiada formula; anda brute-force nonce sehingga cincang muat. Menyemak penyelesaian adalah segera, tetapi mencari penyelesaian memerlukan usaha. Asimetri itu adalah nadi Bukti Kerja.

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()

Langkah 3 - Merantai blok

Setiap blok baharu menyimpan cincangan yang sebelumnya, mengimpalnya ke dalam rantai yang bermula dengan blok "genesis" berkod keras. Oleh kerana setiap blok berkomitmen kepada yang sebelum itu, susunan itu ditetapkan dan sejarahnya dipautkan bersama.

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

Langkah 4 — Mengesahkan rantaian

Untuk mempercayai rantaian, anda menyemaknya semula: setiap blok mesti menunjuk ke cincang sebenar blok sebelumnya dan setiap blok mesti memenuhi peraturan bukti kerja. Jika mana-mana semakan gagal di mana-mana, rantai itu tidak sah.

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

Langkah 5 — Jalankan dan cuba menipu

Sekarang tambah beberapa blok dan kemudian ganggu transaksi lama. Sebaik sahaja anda menukar data lalu, cincangan blok itu tidak lagi sepadan dengan jangkaan blok seterusnya — dan pengesahan serta-merta mengembalikan Palsu. Inilah, dalam bentuk kecil, mengapa anda tidak boleh menulis semula sejarah Bitcoin secara senyap-senyap.

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!

Apa yang ditambahkan oleh Bitcoin sebenar

Rantai mainan kami mengajar rangka. Real Bitcoin menambah rangkaian nod peer-to-peer global, tandatangan digital yang membuktikan siapa yang boleh membelanjakan syiling, pelarasan kesukaran automatik, model UTXO, menyekat ganjaran dan separuh, dan peraturan konsensus yang membenarkan orang yang tidak dikenali bersetuju tanpa kepercayaan. Teroka setiap satu dalam penjelasan kami di bawah.

Soalan lazim

Teruskan belajar