...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 9 · Blocuri

Lanțul: fiecare bloc indică spre cel dinainte

Un bloc singur este doar o pagină. Ce face din blocuri un lanț este câmpul hash_anterior: fiecare bloc păstrează amprenta blocului de dinaintea lui. În această lecție creezi blocul geneză și legi blocurile unul de altul în Python.

Legătura: hash_anterior

Imaginează-ți un caiet în care, pe fiecare pagină nouă, copiezi sigiliul paginii anterioare. Dacă cineva rupe sau modifică o pagină, sigiliul copiat pe pagina următoare nu se mai potrivește. Exact asta face hash_anterior.

Bloc 0 (geneză)hash_anterior0000…000dateGenezahashd209…3b3Bloc 1hash_anteriord209…3b3dateAna -> Bogdan: 10hashc20c…4acBloc 2hash_anteriorc20c…4acdateBogdan -> Cristina: 4hash364c…f2fhash-ul fiecărui bloc este copiat în câmpul hash_anterior al blocului următor
Trei blocuri din exemplul lecției: hash-ul fiecărui bloc (teal) apare ca hash_anterior (galben) în blocul următor.
Direcția legăturii

Fiecare bloc indică înapoi, spre blocul vechi. Un bloc nu știe nimic despre blocurile care vor veni după el, pentru că hash-ul lor nu există încă atunci când el este creat.

Blocul geneză

Primul bloc nu are niciun bloc înaintea lui. Prin convenție, câmpul lui hash_anterior conține 64 de zerouri ("0" * 64). El se numește blocul geneză (genesis block) și este scris direct în codul programului: toate nodurile pornesc de la același geneză.

Blocul geneză Bitcoin (blocul 0)data3 ianuarie 2009, 18:15:05 UTC (timestamp 1231006505)hash anterior0000000000…0000 (64 de zerouri)nonce2083236893recompensă50 BTC (nu pot fi cheltuiți)hash000000000019d6689c085ae1…8ce26f
Blocul geneză real al rețelei Bitcoin, creat de Satoshi Nakamoto: hash-ul anterior este format numai din zerouri.

Pentru blocurile noastre folosim funcția hash_bloc din lecția trecută, cu o mică schimbare: blocul păstrează acum și propriul hash în câmpul hash, dar hash-ul se calculează din toate celelalte câmpuri (dictionary comprehension-ul sare peste cheia hash). Funcția creeaza_bloc construiește blocul și îi adaugă amprenta:

import hashlib, json

def hash_bloc(bloc):
    continut = {k: v for k, v in bloc.items() if k != "hash"}
    text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode()).hexdigest()

def creeaza_bloc(index, date, hash_anterior):
    bloc = {"index": index, "timestamp": 1700000000 + index * 600,
            "date": date, "hash_anterior": hash_anterior}
    bloc["hash"] = hash_bloc(bloc)
    return bloc

geneza = creeaza_bloc(0, "Geneza", "0" * 64)
print(geneza["index"], geneza["hash_anterior"][:12])
print(geneza["hash"])
0 000000000000
d2091b27f7b9191c744ead8737800c9b4b68dd0ee434a5670aeeda30d6b053b3

Legăm blocurile

Fiecare bloc nou primește ca hash_anterior hash-ul blocului creat înainte:

import hashlib, json

def hash_bloc(bloc):
    continut = {k: v for k, v in bloc.items() if k != "hash"}
    text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode()).hexdigest()

def creeaza_bloc(index, date, hash_anterior):
    bloc = {"index": index, "timestamp": 1700000000 + index * 600,
            "date": date, "hash_anterior": hash_anterior}
    bloc["hash"] = hash_bloc(bloc)
    return bloc

geneza = creeaza_bloc(0, "Geneza", "0" * 64)
b1 = creeaza_bloc(1, "Ana -> Bogdan: 10", geneza["hash"])
b2 = creeaza_bloc(2, "Bogdan -> Cristina: 4", b1["hash"])

for bloc in [geneza, b1, b2]:
    print(bloc["index"], bloc["hash_anterior"][:12], "->", bloc["hash"][:12])
0 000000000000 -> d2091b27f7b9
1 d2091b27f7b9 -> c20cf0a09328
2 c20cf0a09328 -> 364ce6fff828

Observă că primele 12 caractere ale lui hash_anterior din blocul 1 sunt chiar începutul hash-ului geneză, iar ale blocului 2 sunt începutul hash-ului blocului 1.

Lanțul ca listă

Lanțul întreg este o listă de blocuri. Ultimul bloc este lant[-1], iar indexul blocului nou este chiar len(lant):

import hashlib, json

def hash_bloc(bloc):
    continut = {k: v for k, v in bloc.items() if k != "hash"}
    text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode()).hexdigest()

def creeaza_bloc(index, date, hash_anterior):
    bloc = {"index": index, "timestamp": 1700000000 + index * 600,
            "date": date, "hash_anterior": hash_anterior}
    bloc["hash"] = hash_bloc(bloc)
    return bloc

lant = [creeaza_bloc(0, "Geneza", "0" * 64)]
for date in ["Ana -> Bogdan: 10", "Bogdan -> Cristina: 4"]:
    ultimul = lant[-1]
    lant.append(creeaza_bloc(len(lant), date, ultimul["hash"]))

print("Blocuri:", len(lant))
print(lant[2]["hash_anterior"] == lant[1]["hash"])
Blocuri: 3
True

De ce contează ordinea câmpurilor din hash

1
Hash-ul blocului 1 depinde de datele lui și de hash_anterior, deci de hash-ul geneză.
2
Hash-ul blocului 2 depinde de hash-ul blocului 1, deci, indirect, și de geneză.
3
Așadar ultimul hash din lanț depinde de toate blocurile de dinainte: este un rezumat al întregului istoric.
4
Două noduri care au același ultim hash au, practic sigur, exact același lanț.
Un singur hash pentru tot istoricul

Pentru a verifica dacă două copii ale lanțului sunt identice, nodurile nu compară blocurile unul câte unul: compară hash-ul ultimului bloc.

Greșeli frecvente

  • **Folosești același hash_anterior pentru toate blocurile. Fiecare bloc trebuie să primească hash-ul blocului imediat anterior**, deci lant[-1]["hash"] în momentul creării.
  • Calculezi hash-ul înainte să completezi toate câmpurile. Orice câmp adăugat după calcul nu este protejat de hash.
  • **Includ câmpul hash în calcul.** Ar trebui să știi rezultatul înainte să-l calculezi; de aceea hash_bloc sare peste el.
  • **Geneza cu hash_anterior = "0".** Merge, dar convenția este 64 de zerouri, ca toate hash-urile să aibă aceeași lungime.

Lanțuri în lumea reală

₿Peste 900 000 de blocuri

Lanțul Bitcoin are acum peste 900 000 de blocuri, fiecare legat de cel dinainte, până la geneza din 2009.

Git

Fiecare commit conține hash-ul commit-ului părinte: istoricul unui proiect este tot un lanț de hash-uri.

Certificate Transparency

Jurnalele publice ale certificatelor HTTPS folosesc tot structuri de hash-uri ca să nu poată fi modificate pe ascuns.

Haber și Stornetta (1991)

Au propus legarea documentelor prin hash pentru datare sigură; ideea apare citată în whitepaper-ul Bitcoin.

Exercițiul tău

Folosind funcțiile hash_bloc și creeaza_bloc date, construiește un lanț de 3 blocuri cu datele Bloc geneză, Cristina -> Dan: 3 și Dan -> Ana: 1 (geneza are hash_anterior format din 64 de zerouri). Apoi afișează pentru fiecare bloc o linie de forma 0 | anterior: 000000000000 | hash: 1a2b3c4d5e6f, cu primele 12 caractere din hash_anterior și din hash.

  • Creează geneza cu creeaza_bloc(0, "Bloc geneză", "0" * 64) și pune-o într-o listă lant.
  • Adaugă celelalte două blocuri, fiecare cu hash_anterior egal cu hash-ul ultimului bloc din lanț.
  • Parcurge lanțul și afișează indexul, primele 12 caractere din hash_anterior și din hash.
În buclă: lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"])). La afișare: f"{b['index']} | anterior: {b['hash_anterior'][:12]} | hash: {b['hash'][:12]}".

Soluția exercițiului

import hashlib, json

def hash_bloc(bloc):
    continut = {k: v for k, v in bloc.items() if k != "hash"}
    text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode()).hexdigest()

def creeaza_bloc(index, date, hash_anterior):
    bloc = {"index": index, "timestamp": 1700000000 + index * 600,
            "date": date, "hash_anterior": hash_anterior}
    bloc["hash"] = hash_bloc(bloc)
    return bloc


lant = [creeaza_bloc(0, "Bloc geneză", "0" * 64)]
for date in ["Cristina -> Dan: 3", "Dan -> Ana: 1"]:
    lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))

for b in lant:
    print(f"{b['index']} | anterior: {b['hash_anterior'][:12]} | hash: {b['hash'][:12]}")
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași în blockchain Lecția 9 · Lanțul: fiecare bloc indică spre cel dinainte
Progres 0% 0 din 17
Lecția curentă 9 / 15 Blocuri