Merkle Tree & Proof of Work: Cara Blok Bitcoin Diamankan

Sebuah blockchain, sesuai namanya, adalah rantai blok. Tiap blok berisi sekumpulan transaksi, dan tiap blok “mengunci” blok sebelumnya sehingga sejarahnya hampir mustahil diubah. Dua bahan utama yang membuat ini bekerja adalah Merkle tree (untuk meringkas transaksi) dan Proof of Work (untuk mengamankan blok). Mari kita bedah keduanya.

1. Fondasinya: fungsi hash SHA-256

Semuanya bertumpu pada fungsi hash SHA-256. Fungsi ini mengubah data berukuran apa pun menjadi sidik jari sepanjang 256 bit (64 karakter heksadesimal). Sifat pentingnya:

Deterministik — input sama selalu menghasilkan hash sama.
Efek longsor (avalanche) — mengubah satu bit input mengubah hash secara total.
Satu arah — dari hash tidak bisa dikembalikan ke input aslinya.

import hashlib

def sha256(data):
    if isinstance(data, str):
        data = data.encode()
    return hashlib.sha256(data).hexdigest()

print(sha256("Alice->Bob: 2 BTC"))
# 352efa4149fe585d...

2. Merkle tree: meringkas ribuan transaksi

Sebuah blok bisa memuat ribuan transaksi. Daripada menyimpan semuanya untuk diverifikasi, Bitcoin memadatkannya menjadi satu hash tunggal bernama Merkle root.

Caranya bertingkat: setiap transaksi di-hash menjadi daun (leaf), lalu pasangan hash digabung dan di-hash lagi, terus naik sampai tersisa satu hash di puncak. Bila jumlah simpul pada suatu tingkat ganjil, simpul terakhir diduplikasi.

Membangun Merkle root dari empat transaksi secara bertingkat

Empat transaksi → empat leaf hash → dua hash gabungan → satu Merkle root.

def merkle_root(txs):
    if not txs:
        return sha256("")
    layer = [sha256(tx) for tx in txs]
    while len(layer) > 1:
        if len(layer) % 2 == 1:         # jumlah ganjil
            layer.append(layer[-1])     # duplikat simpul terakhir
        layer = [sha256(layer[i] + layer[i + 1])
                 for i in range(0, len(layer), 2)]
    return layer[0]

txs = [
    "Alice->Bob: 2 BTC",
    "Bob->Carol: 1 BTC",
    "Dave->Eve: 5 BTC",
    "Frank->Grace: 3 BTC",
]
print(merkle_root(txs))
# 1eaba7bab7d1f5888ef347e23a75d1041959cb5911963f018eb03853fef6143d

Kelebihannya besar: untuk membuktikan sebuah transaksi ada di dalam blok, kita cukup menyediakan segelintir hash di sepanjang jalur menuju root (disebut Merkle proof) — tanpa perlu mengunduh seluruh transaksi. Inilah yang memungkinkan dompet ringan (SPV) memverifikasi transaksi tanpa menyimpan seluruh blockchain.

3. Struktur blok dan rantainya

Setiap blok punya header yang (disederhanakan) berisi:

Hash blok sebelumnya — inilah “rantai” yang menyambungkan blok.
Merkle root — ringkasan semua transaksi di blok ini.
Timestamp, target (tingkat kesulitan), dan nonce.

Karena header memuat hash blok sebelumnya, mengubah satu blok lama akan mengubah hash-nya, yang memutus sambungan ke semua blok sesudahnya. Untuk memalsukan, penyerang harus membangun ulang seluruh blok setelahnya — dan di sinilah Proof of Work menjadi tembok mahal.

Tiga blok yang saling terkait lewat hash blok sebelumnya

Tiap blok menunjuk ke hash blok sebelumnya. Mengubah satu transaksi mengubah Merkle root → hash blok → memutus seluruh rantai setelahnya.

4. Proof of Work: mengunci blok dengan kerja

Agar sebuah blok sah, hash dari header-nya harus lebih kecil dari sebuah target — dengan kata lain, hash harus diawali sejumlah angka nol tertentu. Satu-satunya cara menemukannya adalah mencoba-coba: mengganti angka nonce berulang kali sampai hash-nya memenuhi syarat. Proses inilah yang disebut mining.

def mine(header, difficulty):
    prefix = "0" * difficulty          # target: hash diawali 'difficulty' nol
    nonce = 0
    while True:
        h = sha256(f"{header}{nonce}")
        if h.startswith(prefix):
            return nonce, h
        nonce += 1

root = merkle_root(txs)
header = f"prev=00000000;merkle={root};time=1700000000;"

print(mine(header, 4))
# (82602, '0000e54c888098018139...')
print(mine(header, 5))
# (1112896, '00000682b5957c47f4c6...')

Perhatikan lonjakannya: menambah syarat dari 4 nol ke 5 nol membuat jumlah percobaan melonjak dari ~82 ribu menjadi ~1,1 juta. Setiap nol tambahan membuat mining kira-kira 16× lebih sulit. Di jaringan Bitcoin sungguhan, target ini disetel otomatis (difficulty adjustment) agar rata-rata satu blok ditemukan tiap ~10 menit, berapa pun total daya komputasi penambang.

5. Mengapa sulit dipalsukan

Gabungan kedua mekanisme ini menghasilkan keamanan berlapis:

Mengubah satu transaksi → mengubah Merkle root → mengubah hash header → nonce lama tak lagi valid.
Penyerang harus menambang ulang blok itu dan semua blok sesudahnya, lebih cepat daripada seluruh jaringan jujur menambah blok baru.
Untuk konsisten menang, penyerang perlu menguasai >50% daya komputasi jaringan (serangan 51%) — secara ekonomi sangat mahal pada jaringan besar.

Jadi “kerja” dari Proof of Work bukan pemborosan belaka: ia adalah biaya nyata yang membuat memutarbalikkan sejarah menjadi tidak sepadan.

Penutup

Merkle tree memadatkan banyak transaksi menjadi satu Merkle root, dan memungkinkan pembuktian ringkas.
Proof of Work mengunci blok dengan memaksa penambang menemukan nonce hingga hash memenuhi target.
Keduanya saling menguatkan: satu perubahan kecil merembet ke seluruh rantai, dan membangunnya ulang butuh energi yang tak sepadan.

Dari dua gagasan sederhana — menghash berpasangan, dan menebak nonce — lahir buku besar yang bisa dipercaya tanpa perlu mempercayai satu pihak pun.