...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 11 · Proiect

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.

creeaza_geneza()lanțul cu blocul 0adauga_bloc(lant, date)leagă și adaugă un bloceste_valid(lant)verifică hash-uri și legăturihash_bloc(bloc)folosită de toate trei
Cele trei funcții publice ale blockchain-ului nostru, toate sprijinite pe hash_bloc.
FuncțiePrimeșteÎntoarce
hash_bloc(bloc)un blochash-ul calculat din toate câmpurile în afară de hash
creeaza_geneza()nimicun lanț nou: o listă cu blocul geneză
adauga_bloc(lant, date)lanțul și datele noului blocblocul creat (și îl adaugă la final)
este_valid(lant)lanțulTrue 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
Cine calculează indexul?

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

creeaza_geneza()Bloc 0e3af…1dbadauga_bloc(…)Bloc 0e3af…1dbBloc 18338…fffadauga_bloc(…)Bloc 0e3af…1dbBloc 18338…fffBloc 2b622…6ce
Lanțul din exemplu crește bloc cu bloc: geneza, apoi câte un bloc nou legat de ultimul (hash-urile reale, scurtate).
1
creeaza_geneza() întoarce [geneza], o listă cu un singur bloc.
2
adauga_bloc citește lant[-1], ultimul bloc, și construiește blocul următor din el.
3
Calculează hash-ul noului bloc, apoi îl adaugă cu append. Lista este modificată pe loc, deci nu trebuie să o întorci.
4
este_valid verifică la final întregul lanț.

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:

Minarea

Acum oricine poate rescrie lanțul în milisecunde; Proof of Work face fiecare bloc scump.

Semnăturile

Oricine poate scrie „Ana -> Bogdan”; cu semnături digitale doar Ana poate autoriza plata.

Rețeaua

Lanțul trăiește într-un singur program; în realitate e copiat pe mii de noduri care se sincronizează.

Soldurile

Nimeni nu verifică dacă Ana are bani; vei combina lanțul cu regula din lecția 4.

Exercițiul tău

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).
Poți pune tranzacțiile într-o listă de tupluri (de, catre, suma) și să apelezi adauga_bloc într-o buclă.

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))
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 11 · Primul tău blockchain în 30 de linii
Progres 0% 0 din 17
Lecția curentă 11 / 15 Proiect