Recapitulare: registrul clasei
Ai terminat primul modul. Știi ce este un registru distribuit, de ce banii digitali se pot cheltui de două ori, cum funcționează un hash, cum se leagă blocurile și de ce rețeaua are nevoie de consens. În această recapitulare legi totul într-un mini-proiect: registrul de puncte al unei clase, ținut pe un blockchain.
Harta modulului
| Concept | Pe scurt | În Python |
|---|---|---|
| Registru | istoricul tuturor tranzacțiilor; soldurile se calculează din el | listă de dicționare |
| Dubla cheltuială | aceiași bani trimiși de două ori; o oprește ordinea comună | if sold >= suma |
| Hash | amprentă de 64 de caractere hex, deterministă, cu efect de avalanșă | hashlib.sha256(text.encode()).hexdigest() |
| Serializare | aceleași date → același text | json.dumps(..., sort_keys=True, separators=(",", ":")) |
| Lanț | fiecare bloc păstrează hash-ul celui anterior | bloc["hash_anterior"] = lant[-1]["hash"] |
| Validare | hash propriu corect + legătură corectă | este_valid(lant) |
| Rețea | noduri cu câțiva vecini, fiecare cu o copie | dicționar de vecini |
| Consens | acord între străini; votul trebuie să coste | dicționar de frecvențe + max |
Verifică-ți cunoștințele
Înainte să rulezi, încearcă să ghicești rezultatul. Ce text produce serializarea, câte caractere are hash-ul și câți octeți are litera „ș”?
import hashlib, json
a = json.dumps({"b": 1, "a": 2}, sort_keys=True, separators=(",", ":"))
print(a)
print(len(hashlib.sha256(a.encode()).hexdigest()))
print(len("ș".encode())){"a":2,"b":1}
64
2- Cheile sunt sortate (a înaintea lui b) și nu există spații.
- Un hash SHA-256 în hex are mereu 64 de caractere.
- „ș” ocupă 2 octeți în UTF-8.
Mini-proiectul: registrul de puncte al clasei
Profesoara dă puncte de activitate, iar colegii își pot transfera puncte unii altora. Ca nimeni să nu poată modifica pe ascuns cine cui a dat, tranzacțiile se scriu într-un blockchain. Câmpul date se numește acum tranzactii, iar suma se numește puncte.
Toate tranzacțiile din lanț le aduni într-o singură listă cu un list comprehension cu două for: pentru fiecare bloc, pentru fiecare tranzacție din el.
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, "tranzactii": [], "hash_anterior": "0" * 64}
bloc["hash"] = hash_bloc(bloc)
return [bloc]
def adauga_bloc(lant, tranzactii):
ultimul = lant[-1]
bloc = {"index": ultimul["index"] + 1, "timestamp": ultimul["timestamp"] + 600,
"tranzactii": tranzactii, "hash_anterior": ultimul["hash"]}
bloc["hash"] = hash_bloc(bloc)
lant.append(bloc)
lant = creeaza_geneza()
adauga_bloc(lant, [{"de": "Ana", "catre": "Bogdan", "puncte": 5}])
adauga_bloc(lant, [{"de": "Bogdan", "catre": "Ana", "puncte": 2},
{"de": "Cristina", "catre": "Ana", "puncte": 1}])
toate = [tx for bloc in lant for tx in bloc["tranzactii"]]
print("Blocuri:", len(lant), "| tranzacții:", len(toate))
for tx in toate:
print(tx["de"], "->", tx["catre"], tx["puncte"])Blocuri: 3 | tranzacții: 3 Ana -> Bogdan 5 Bogdan -> Ana 2 Cristina -> Ana 1
Soldurile nu se păstrează nicăieri: le calculezi din toate tranzacțiile, din toate blocurile, în ordine. Dacă lanțul e valid, oricine obține exact aceleași solduri.
Pașii proiectului
Nu verifică dacă un coleg are destule puncte (regula din lecția 4) și nu are semnături: oricine poate scrie o tranzacție în numele altcuiva. Semnăturile digitale vin în modulul următor.
Greșeli frecvente
- Calculezi soldurile doar din ultimul bloc. Soldul depinde de tot istoricul.
- Validarea după calculul soldurilor. Validezi întâi: dintr-un lanț invalid nu are sens să calculezi nimic.
- Uiți geneza la validare. Geneza nu are bloc anterior, dar hash-ul ei trebuie să fie corect.
- Modifici dicționarul cu punctele inițiale. Lucrează pe o copie (dict(initial)), ca să poți recalcula oricând.
Ce urmează
Coliziuni, Merkle, chei publice și private, curbe eliptice, semnături ECDSA și adrese.
Tranzacții reale, UTXO, Proof of Work și dificultate.
Propagare, fork-uri, cel mai lung lanț, Proof of Stake.
Un blockchain complet în Python, cu tranzacții semnate și noduri care se sincronizează.
Completează funcțiile este_valid(lant) și solduri(lant, initial). Construiește lanțul cu 3 blocuri (după geneză) cu tranzacțiile date, afișează Valid: True, apoi soldurile finale de puncte, sortate după nume, în forma Nume: puncte. Toți colegii pornesc cu 20 de puncte.
- Creează lanțul și adaugă cele 3 blocuri din lista blocuri.
- Scrie este_valid(lant): pentru fiecare bloc verifică hash-ul, iar pentru i > 0 și legătura cu blocul anterior.
- Scrie solduri(lant, initial): pornește de la dict(initial) și aplică tranzacțiile din toate blocurile, în ordine.
- Afișează Valid: True, apoi soldurile sortate după nume.
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, "tranzactii": [], "hash_anterior": "0" * 64}
bloc["hash"] = hash_bloc(bloc)
return [bloc]
def adauga_bloc(lant, tranzactii):
ultimul = lant[-1]
bloc = {"index": ultimul["index"] + 1, "timestamp": ultimul["timestamp"] + 600,
"tranzactii": tranzactii, "hash_anterior": ultimul["hash"]}
bloc["hash"] = hash_bloc(bloc)
lant.append(bloc)
def este_valid(lant):
for i, bloc in enumerate(lant):
if bloc["hash"] != hash_bloc(bloc):
return False
if i > 0 and bloc["hash_anterior"] != lant[i - 1]["hash"]:
return False
return True
def solduri(lant, initial):
rez = dict(initial)
for bloc in lant:
for tx in bloc["tranzactii"]:
rez[tx["de"]] = rez.get(tx["de"], 0) - tx["puncte"]
rez[tx["catre"]] = rez.get(tx["catre"], 0) + tx["puncte"]
return rez
initial = {"Ana": 20, "Bogdan": 20, "Cristina": 20, "Dan": 20}
blocuri = [
[{"de": "Ana", "catre": "Bogdan", "puncte": 5}, {"de": "Dan", "catre": "Cristina", "puncte": 3}],
[{"de": "Bogdan", "catre": "Ana", "puncte": 8}],
[{"de": "Cristina", "catre": "Dan", "puncte": 1}, {"de": "Bogdan", "catre": "Cristina", "puncte": 4}],
]
lant = creeaza_geneza()
for tranzactii in blocuri:
adauga_bloc(lant, tranzactii)
print("Valid:", este_valid(lant))
final = solduri(lant, initial)
for nume in sorted(final):
print(f"{nume}: {final[nume]}") 