...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 15 · Recapitulare

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

Registru (ledger)lecțiile 1, 3Dubla cheltuialălecția 4Hash SHA-256lecțiile 5–7Bloc + serializarelecția 8Lanț + validarelecțiile 9–11Noduri și rețealecția 12Consenslecția 13Public / privatlecția 14
Conceptele primului modul și legăturile dintre ele: registrul, hash-ul, blocul, lanțul, rețeaua, consensul și tipurile de blockchain.
ConceptPe scurtÎn Python
Registruistoricul tuturor tranzacțiilor; soldurile se calculează din ellistă de dicționare
Dubla cheltuialăaceiași bani trimiși de două ori; o oprește ordinea comunăif sold >= suma
Hashamprentă de 64 de caractere hex, deterministă, cu efect de avalanșăhashlib.sha256(text.encode()).hexdigest()
Serializareaceleași date → același textjson.dumps(..., sort_keys=True, separators=(",", ":"))
Lanțfiecare bloc păstrează hash-ul celui anteriorbloc["hash_anterior"] = lant[-1]["hash"]
Validarehash propriu corect + legătură corectăeste_valid(lant)
Rețeanoduri cu câțiva vecini, fiecare cu o copiedicționar de vecini
Consensacord între străini; votul trebuie să costedicț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.

tranzacțiilistă de dicționareblocuriadauga_blocvalidareeste_validsolduridin tot istoricul
Fluxul mini-proiectului: tranzacțiile intră în blocuri, lanțul se validează, iar soldurile se calculează din tot istoricul.

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
De ce soldurile din tot lanțul?

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

1
Creezi lanțul cu creeaza_geneza().
2
Adaugi blocurile, fiecare cu lista lui de tranzacții.
3
Verifici lanțul: fiecare bloc are hash-ul corect și indică spre hash-ul blocului anterior.
4
Pornind de la punctele inițiale, aplici toate tranzacțiile din toate blocurile, în ordine.
5
Afișezi soldurile sortate după nume.
Ce nu face încă proiectul

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ă

Criptografie

Coliziuni, Merkle, chei publice și private, curbe eliptice, semnături ECDSA și adrese.

Bitcoin și minare

Tranzacții reale, UTXO, Proof of Work și dificultate.

Rețele și consens

Propagare, fork-uri, cel mai lung lanț, Proof of Stake.

Propriul blockchain

Un blockchain complet în Python, cu tranzacții semnate și noduri care se sincronizează.

Exercițiul tău

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.
În solduri: for bloc in lant: for tx in bloc["tranzactii"]: ... cu -= la de și += la catre.

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]}")
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 15 · Recapitulare: registrul clasei
Progres 0% 0 din 17
Lecția curentă 15 / 15 Recapitulare