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).
| Câmp | Ce reprezintă | Exemplu |
|---|---|---|
| index | poziția blocului în lanț (în Bitcoin se numește „înălțime”) | 1 |
| timestamp | momentul creării, în secunde de la 1 ianuarie 1970 (timp Unix) | 1700000600 |
| date | tranzacțiile sau alte date | "Ana -> Bogdan: 10" |
| hash_anterior | hash-ul blocului dinainte: legătura din lanț | 64 de caractere hex |
| nonce | un număr pe care minerii îl tot schimbă (lecțiile despre minare) | 0 |
| hash | amprenta blocului, calculată din toate câmpurile de mai sus | 64 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
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.
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
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
Un bloc nou la aproximativ 10 minute, cu câteva mii de tranzacții; antetul are mereu 80 de octeți.
Un bloc la 12 secunde; antetul conține, printre altele, rădăcina stării tuturor conturilor.
Poți deschide orice bloc Bitcoin și vedea câmpurile din tabel: înălțime, timp, hash anterior, nonce.
Multe sisteme de semnături folosesc aceeași idee: o formă canonică a datelor înainte de hash.
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.
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)) 