Bangun Blockchain Anda Sendiri

Langkah 1 — Sebuah blok dan sidik jarinya

Sebuah blok menyimpan beberapa data (transaksi), link ke blok sebelumnya, dan "nonce" (angka yang dapat kita ubah). Identitasnya adalah hash SHA-256 dari semua isinya — ubah satu karakter dan hashnya berubah sepenuhnya. Hash tersebut adalah sidik jari blok yang dapat dirusak.

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 — Penambangan (Bukti Kerja)

Menambang berarti menemukan hash yang memenuhi aturan — di sini, dimulai dengan sejumlah angka nol. Tidak ada rumusnya; Anda melakukan brute force pada nonce sampai hashnya cocok. Memeriksa solusinya bersifat instan, tetapi menemukannya membutuhkan kerja keras. Asimetri tersebut adalah inti dari Proof of Work.

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 — Merangkai balok

Setiap blok baru menyimpan hash dari blok sebelumnya, menyatukannya menjadi sebuah rantai yang dimulai dengan blok "genesis" yang dikodekan secara keras. Karena setiap blok berkomitmen pada blok sebelumnya, urutannya tetap dan riwayatnya dihubungkan 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 — Memvalidasi rantai

Untuk memercayai suatu rantai, Anda harus memeriksanya kembali: setiap blok harus menunjuk ke hash sebenarnya dari blok sebelumnya, dan setiap blok harus memenuhi aturan bukti kerja. Jika salah satu pemeriksaan gagal di mana pun, rantai tersebut tidak valid.

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 coba curang

Sekarang tambahkan beberapa blok dan kemudian ubah transaksi lama. Saat Anda mengubah data sebelumnya, hash blok tersebut tidak lagi sesuai dengan apa yang diharapkan oleh blok berikutnya — dan validasi langsung mengembalikan False. Inilah, secara singkat, mengapa Anda tidak bisa diam-diam menulis ulang sejarah 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!

Apa yang ditambahkan oleh Bitcoin asli

Rantai mainan kami mengajarkan kerangka. Bitcoin Asli menambahkan jaringan node peer-to-peer global, tanda tangan digital yang membuktikan siapa yang dapat membelanjakan koin, penyesuaian kesulitan otomatis, model UTXO, memblokir hadiah dan separuh, dan aturan konsensus yang memungkinkan orang asing setuju tanpa kepercayaan. Jelajahi masing-masing dalam penjelasan kami di bawah ini.

Pertanyaan yang sering diajukan

Terus belajar