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

Structura unui bloc

Un bloc este o pagină din registru: conține tranzacții și câteva câmpuri care îl leagă de restul lanțului. În această lecție vezi ce câmpuri are un bloc, cum îl reprezinți în Python ca dicționar și cum îl transformi în text mereu la fel, ca să-i poți calcula hash-ul.

Ce conține un bloc

Orice bloc are două părți: un antet (header), cu informații despre bloc, și un corp, cu tranzacțiile. În Bitcoin antetul are exact 80 de octeți și doar el intră direct în hash; tranzacțiile sunt „rezumate” în antet printr-un singur hash, rădăcina Merkle (lecția 20).

Bloc BitcoinAntet (80 de octeți)versiune4 octețihash anterior32 octețirădăcina Merkle32 octețitimp4 octețidificultate4 octeținonce4 octețiCorp: lista de tranzacțiitx 0tx 1tx 2tx 3…hash-ul blocului = SHA-256 dublu al antetului; tranzacțiile intră în hash prin rădăcina Merkle
Anatomia unui bloc Bitcoin: antetul de 80 de octeți (cu hash-ul anterior și nonce-ul evidențiate) și corpul cu lista de tranzacții.
CâmpCe reprezintăExemplu
indexpoziția blocului în lanț (în Bitcoin se numește „înălțime”)1
timestampmomentul creării, în secunde de la 1 ianuarie 1970 (timp Unix)1700000600
datetranzacțiile sau alte date"Ana -> Bogdan: 10"
hash_anteriorhash-ul blocului dinainte: legătura din lanț64 de caractere hex
nonceun număr pe care minerii îl tot schimbă (lecțiile despre minare)0
hashamprenta blocului, calculată din toate câmpurile de mai sus64 de caractere hex

Blocul ca dicționar Python

Un dicționar este forma naturală pentru un bloc: fiecare câmp este o cheie. Timestamp-ul îl scriem ca număr fix (în cursul acesta nu folosim ora curentă, ca rezultatele să fie aceleași la fiecare rulare).

bloc = {
    "index": 1,
    "timestamp": 1700000600,
    "date": "Ana -> Bogdan: 10",
    "hash_anterior": "0" * 64,
    "nonce": 0,
}

print(bloc["index"], bloc["date"])
print(len(bloc["hash_anterior"]))
1 Ana -> Bogdan: 10
64
Timp Unix

1700000000 înseamnă 14 noiembrie 2023, ora 22:13:20 UTC. Bitcoin păstrează timpul în același format, ca număr de secunde.

Serializarea: din dicționar în text, mereu la fel

SHA-256 primește octeți, deci blocul trebuie transformat întâi în text. Operația se numește serializare. Problema: același dicționar poate fi scris ca text în mai multe feluri (altă ordine a cheilor, alte spații), iar fiecare variantă ar da alt hash.

import json

a = {"suma": 10, "de": "Ana"}
b = {"de": "Ana", "suma": 10}

print(json.dumps(a))
print(json.dumps(b))
print(json.dumps(a, sort_keys=True, separators=(",", ":")))
print(json.dumps(b, sort_keys=True, separators=(",", ":")))
{"suma": 10, "de": "Ana"}
{"de": "Ana", "suma": 10}
{"de":"Ana","suma":10}
{"de":"Ana","suma":10}

Cu sort_keys=True cheile sunt mereu în ordine alfabetică, iar separators=(",", ":") elimină spațiile. Rezultatul: aceleași date → același text → același hash, indiferent cum a fost construit dicționarul și pe ce calculator.

{"index": 1, "date": …, "nonce": 0 …}{"nonce": 0, "index": 1, "date": … }aceleași date, altă ordine a cheilorjson.dumps(sort_keys=True)același text{"date":"Ana -> Bogdan: 10","hash_anterior":…același hash28e841…fab6
Două dicționare cu aceleași date, dar cu cheile în altă ordine, devin același text cu sort_keys=True, deci au același hash.

Hash-ul blocului

Punem cele două operații într-o funcție: serializare deterministă, apoi SHA-256. Orice modificare a unui câmp schimbă hash-ul:

import hashlib, json

def hash_bloc(bloc):
    text = json.dumps(bloc, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode()).hexdigest()

bloc = {"index": 1, "timestamp": 1700000600, "date": "Ana -> Bogdan: 10",
        "hash_anterior": "0" * 64, "nonce": 0}
print(hash_bloc(bloc))

bloc["date"] = "Ana -> Bogdan: 11"
print(hash_bloc(bloc))
28e84114c057f93aba5aa142478d5f49ccaa67ced43f06b8ec2699f770b8fab6
b7e261e2144695e8ec1db69b2a7b7db6ad2077495f6958bdd546d7898af0ccc2
1
Serializezi blocul cu json.dumps(bloc, sort_keys=True, separators=(",", ":")).
2
Transformi textul în octeți cu .encode().
3
Calculezi hashlib.sha256(...).hexdigest().
4
Rezultatul este hash-ul blocului; în lecția următoare îl punem în blocul următor.

Greșeli frecvente

  • **str(bloc) în loc de json.dumps.** str nu sortează cheile și are alt format; două noduri ar putea obține texte diferite pentru același bloc.
  • **Uiți sort_keys=True.** Dicționarele construite în altă ordine dau alt hash.
  • Pui ora curentă în timestamp. Blocul ar avea alt hash la fiecare rulare. Folosește un număr fix.
  • **Pui câmpul hash în datele din care calculezi hash-ul.** Un bloc nu își poate conține propria amprentă; o calculezi din celelalte câmpuri și o adaugi după.

Blocuri reale

₿Bitcoin

Un bloc nou la aproximativ 10 minute, cu câteva mii de tranzacții; antetul are mereu 80 de octeți.

ΞEthereum

Un bloc la 12 secunde; antetul conține, printre altele, rădăcina stării tuturor conturilor.

mempool.space

Poți deschide orice bloc Bitcoin și vedea câmpurile din tabel: înălțime, timp, hash anterior, nonce.

JSON canonic

Multe sisteme de semnături folosesc aceeași idee: o formă canonică a datelor înainte de hash.

Exercițiul tău

Scrie funcția serializeaza(bloc) care întoarce textul JSON determinist al blocului și funcția hash_bloc(bloc) care întoarce SHA-256 al acestui text. Pentru blocul dat, afișează textul serializat și apoi hash-ul.

  • În serializeaza folosește json.dumps cu sort_keys=True și separators=(",", ":").
  • În hash_bloc apelează serializeaza(bloc), transformă în octeți și calculează SHA-256 în hex.
  • Afișează text: urmat de textul serializat și hash: urmat de hash.
return hashlib.sha256(serializeaza(bloc).encode()).hexdigest().

Soluția exercițiului

import hashlib, json


def serializeaza(bloc):
    return json.dumps(bloc, sort_keys=True, separators=(",", ":"))


def hash_bloc(bloc):
    return hashlib.sha256(serializeaza(bloc).encode()).hexdigest()


bloc = {
    "index": 2,
    "timestamp": 1700001200,
    "date": "Bogdan -> Cristina: 4",
    "hash_anterior": "9f2c" + "0" * 60,
    "nonce": 0,
}

print("text:", serializeaza(bloc))
print("hash:", hash_bloc(bloc))
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 8 · Structura unui bloc
Progres 0% 0 din 17
Lecția curentă 8 / 15 Blocuri