Primul tău blockchain în 30 de linii
Ai toate piesele: hash-ul unui bloc, legătura prin hash_anterior și verificarea lanțului. Acum le pui împreună într-un mic program cu patru funcții: un blockchain funcțional, în aproximativ 30 de linii de Python.
Planul programului
Organizăm codul în funcții mici, fiecare cu o singură responsabilitate. Așa le poți testa separat și le poți refolosi în lecțiile următoare.
| Funcție | Primește | Întoarce |
|---|---|---|
| hash_bloc(bloc) | un bloc | hash-ul calculat din toate câmpurile în afară de hash |
| creeaza_geneza() | nimic | un lanț nou: o listă cu blocul geneză |
| adauga_bloc(lant, date) | lanțul și datele noului bloc | blocul creat (și îl adaugă la final) |
| este_valid(lant) | lanțul | True sau False |
Codul complet
Tranzacțiile sunt acum o listă de dicționare în câmpul date: un bloc poate avea mai multe tranzacții, iar geneza are lista goală. json.dumps serializează fără probleme și listele, și dicționarele din ele. Timestamp-ul crește cu 600 de secunde (10 minute, ca la Bitcoin) față de blocul anterior.
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_geneza():
bloc = {"index": 0, "timestamp": 1700000000, "date": [], "hash_anterior": "0" * 64}
bloc["hash"] = hash_bloc(bloc)
return [bloc]
def adauga_bloc(lant, date):
ultimul = lant[-1]
bloc = {
"index": ultimul["index"] + 1,
"timestamp": ultimul["timestamp"] + 600,
"date": date,
"hash_anterior": ultimul["hash"],
}
bloc["hash"] = hash_bloc(bloc)
lant.append(bloc)
return bloc
def este_valid(lant):
for i in range(1, len(lant)):
bloc = lant[i]
if bloc["hash"] != hash_bloc(bloc) or bloc["hash_anterior"] != lant[i - 1]["hash"]:
return False
return lant[0]["hash"] == hash_bloc(lant[0])
lant = creeaza_geneza()
adauga_bloc(lant, [{"de": "Ana", "catre": "Bogdan", "suma": 10}])
adauga_bloc(lant, [{"de": "Bogdan", "catre": "Cristina", "suma": 4},
{"de": "Ana", "catre": "Dan", "suma": 2}])
for bloc in lant:
print(f"Bloc {bloc['index']}: {len(bloc['date'])} tranzacții, hash {bloc['hash'][:16]}")
print("Valid:", este_valid(lant))Bloc 0: 0 tranzacții, hash e3af3c0ee45e8a7c Bloc 1: 1 tranzacții, hash 83388af7031c56a5 Bloc 2: 2 tranzacții, hash b622fb8dca95c17d Valid: True
adauga_bloc ia indexul, timestamp-ul și hash_anterior din ultimul bloc. Cine apelează funcția dă doar datele: nu poate greși legătura nici dacă ar vrea.
Cum crește lanțul
Liste modificate pe loc
adauga_bloc nu întoarce lanțul, ci modifică lista primită. În Python, o listă dată unei funcții este același obiect, nu o copie: lant.append(bloc) din funcție se vede și în afara ei. Întoarcem totuși blocul nou, ca să-l poți afișa direct.
Ce se întâmplă dacă uiți geneza și pornești de la o listă goală? lant[-1] nu are ce element să ia:
lant = [] ultimul = lant[-1]
Python oprește programul cu IndexError: list index out of range (indexul cerut nu există în listă). Un lanț începe întotdeauna cu geneza.
Greșeli frecvente
- **Calculezi hash-ul după append, dar uiți să-l salvezi în bloc.** Blocul ajunge în lanț fără câmpul hash, iar blocul următor dă KeyError: 'hash'.
- Indexul calculat cu un contor separat. Dacă contorul și lanțul se decalează, indexurile se încurcă. Ia-l din ultimul bloc.
- **este_valid care verifică doar ultimul bloc.** Un bloc din mijloc modificat ar trece neobservat.
- Modifici blocul după ce l-ai adăugat. Orice schimbare după calculul hash-ului face blocul invalid; asta e exact ideea.
Ce lipsește încă
Blockchain-ul tău e corect, dar nu e încă unul „adevărat”. Pe parcursul cursului vei adăuga piesele care lipsesc:
Acum oricine poate rescrie lanțul în milisecunde; Proof of Work face fiecare bloc scump.
Oricine poate scrie „Ana -> Bogdan”; cu semnături digitale doar Ana poate autoriza plata.
Lanțul trăiește într-un singur program; în realitate e copiat pe mii de noduri care se sincronizează.
Nimeni nu verifică dacă Ana are bani; vei combina lanțul cu regula din lecția 4.
Folosind funcțiile date (hash_bloc, creeaza_geneza, adauga_bloc, este_valid), creează un lanț și adaugă 3 blocuri, fiecare cu o tranzacție: Ana trimite 5 lui Bogdan, Bogdan trimite 3 Cristinei, Cristina trimite 1 lui Dan. Afișează Lungime: 4, apoi pentru fiecare bloc Bloc i: urmat de primele 16 caractere ale hash-ului, iar la final Valid: True.
- Creează lanțul cu creeaza_geneza().
- Adaugă cele 3 blocuri cu adauga_bloc(lant, [{"de": ..., "catre": ..., "suma": ...}]).
- Afișează Lungime: cu len(lant).
- Afișează fiecare bloc ca Bloc 0: 1a2b3c4d5e6f7a8b și apoi Valid: cu rezultatul lui este_valid(lant).
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_geneza():
bloc = {"index": 0, "timestamp": 1700000000, "date": [], "hash_anterior": "0" * 64}
bloc["hash"] = hash_bloc(bloc)
return [bloc]
def adauga_bloc(lant, date):
ultimul = lant[-1]
bloc = {
"index": ultimul["index"] + 1,
"timestamp": ultimul["timestamp"] + 600,
"date": date,
"hash_anterior": ultimul["hash"],
}
bloc["hash"] = hash_bloc(bloc)
lant.append(bloc)
return bloc
def este_valid(lant):
for i in range(1, len(lant)):
bloc = lant[i]
if bloc["hash"] != hash_bloc(bloc) or bloc["hash_anterior"] != lant[i - 1]["hash"]:
return False
return lant[0]["hash"] == hash_bloc(lant[0])
lant = creeaza_geneza()
for de, catre, suma in [("Ana", "Bogdan", 5), ("Bogdan", "Cristina", 3), ("Cristina", "Dan", 1)]:
adauga_bloc(lant, [{"de": de, "catre": catre, "suma": suma}])
print("Lungime:", len(lant))
for bloc in lant:
print(f"Bloc {bloc['index']}: {bloc['hash'][:16]}")
print("Valid:", este_valid(lant)) 