...
Pregătire interviuri

100 de întrebări de interviu Blockchain, cu răspunsuri

Întrebările despre Blockchain care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Blockchain și criptomonede: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 148 minde citit
Întrebări de interviu Blockchain cu răspunsuri

La interviurile în care se verifică blockchain-ul, întrebările merg rar la nivel de definiții. Intervievatorii vor să vadă că înțelegi mecanismele: de ce o funcție hash face istoria greu de modificat, cum se leagă un arbore Merkle de antetul unui bloc, ce garantează o semnătură ECDSA, cum funcționează modelul UTXO, ce face concret Proof of Work sau Proof of Stake și ce poate sau nu poate face un atacator. Pe lângă teorie, apar des exerciții de cod în Python sau în limbajul echipei: calculul unei rădăcini Merkle, minarea unui bloc, validarea unui lanț, aplicarea unei tranzacții pe setul UTXO.

La nivel junior se verifică fundamentele și capacitatea de a scrie cod corect cu bytes, hash-uri și chei. La nivel mid, intervievatorul caută detaliile protocolului real (formatul antetului, ținta, SegWit, RBF, gas, receipts, BIP32) și înțelegerea compromisurilor dintre securitate, cost și descentralizare. La nivel senior, discuția ajunge la stimulente economice, atacuri subtile (minare egoistă, long-range, maleabilitate, refolosirea nonce-ului), disponibilitatea datelor în rollups și securitatea podurilor.

Întrebările sunt grupate pe teme, în ordinea materiei cursului de Blockchain de pe site, și ordonate în fiecare temă de la junior la senior. Citește întâi răspunsul scurt și încearcă să-l explici cu voce tare, apoi compară-l cu răspunsul detaliat. Rulează codul în Python 3.10 sau mai nou și modifică-l: e cel mai bun mod de a fixa conceptele. Pagina nu conține sfaturi de investiții; tot ce urmează este despre tehnologie.

Funcții hash și arbori Merkle

1 Junior

Ce afișează codul de mai jos și ce proprietate a funcțiilor hash ilustrează?

PYTHON
import hashlib

a = hashlib.sha256(b"abc").hexdigest()
b = hashlib.sha256(b"abd").hexdigest()
print(len(a), a == b)
print(bin(int(a, 16) ^ int(b, 16)).count("1"))

Răspuns scurt: Afișează 64 False, apoi un număr de biți diferiți în jur de 128 din 256. Ilustrează efectul de avalanșă: o schimbare minimă a intrării schimbă cam jumătate din biții ieșirii.

hexdigest() întoarce cei 32 de bytes ai rezultatului SHA-256 scriși în hexazecimal, adică 64 de caractere, indiferent cât de lungă e intrarea. Cele două hash-uri sunt diferite, deci a doua valoare e False.

A doua linie transformă ambele hash-uri în numere întregi, face XOR între ele și numără biții de 1. Un bit de 1 în rezultatul XOR înseamnă o poziție în care hash-urile diferă. Deși abc și abd diferă printr-un singur caracter (de fapt prin doi biți), hash-urile diferă în aproximativ jumătate din cei 256 de biți. Numărul exact variază, dar e mereu în jurul lui 128.

Acesta este efectul de avalanșă. Contează pentru blockchain din două motive:

  • nu poți „ghici” cum să modifici puțin un bloc ca să obții un hash apropiat de cel dorit, deci minarea rămâne o căutare oarbă;
  • orice modificare, oricât de mică, a unei tranzacții se vede imediat, pentru că hash-ul blocului devine complet altul.

Dacă o funcție ar produce hash-uri asemănătoare pentru intrări asemănătoare, ar scurge informație despre intrare și ar permite optimizări de căutare, ceea ce ar rupe și Proof of Work, și integritatea lanțului.

Ce urmărește intervievatorul: Verifică dacă știi ce întoarce hexdigest() și dacă înțelegi avalanșa concret, nu doar ca definiție. Mulți candidați spun „64 de bytes” în loc de 64 de caractere hex, adică 32 de bytes.

2 Junior

De ce dă eroare hashlib.sha256("abc") și care e diferența dintre digest(), hexdigest(), bytes.fromhex() și .hex()?

Răspuns scurt: Funcțiile din hashlib lucrează pe bytes, nu pe text, deci un str trebuie întâi codat cu .encode(). digest() dă bytes brute, hexdigest() dă textul hex; .hex() și bytes.fromhex() convertesc între cele două.

În Python 3, str este text Unicode, iar o funcție hash lucrează pe o secvență de bytes. Același text poate avea reprezentări diferite în UTF-8, UTF-16 sau Latin-1, deci Python te obligă să alegi explicit: "abc".encode() (implicit UTF-8). Altfel primești TypeError: Strings must be encoded before hashing.

PYTHON
import hashlib

h = hashlib.sha256("abc".encode())
raw = h.digest()        # 32 de bytes
text = h.hexdigest()    # 64 de caractere hex
assert raw.hex() == text
assert bytes.fromhex(text) == raw

De ce contează în blockchain:

  • double SHA-256 se aplică pe bytes: sha256(sha256(x).digest()). Dacă aplici al doilea hash pe hexdigest(), obții alt rezultat, incompatibil cu Bitcoin.
  • câmpurile din antetul unui bloc sunt concatenate ca bytes cu lungimi fixe, nu ca text.
  • un hash afișat în hex are 64 de caractere, dar ocupă 32 de bytes în bloc.

O greșeală frecventă în proiectele de curs este amestecul: o funcție întoarce hex, alta așteaptă bytes, iar comparațiile == dau mereu False fără nicio eroare. Regula sănătoasă: în interior lucrezi cu bytes, iar hex folosești doar la afișare și în JSON.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai scris efectiv cod cu hash-uri. Candidații care au doar teorie aplică al doilea SHA-256 pe textul hex și nu înțeleg de ce nu se potrivește cu Bitcoin.

Eroarea, în practică:Strings must be encoded before hashing'_sha2.SHA256Type' object is not subscriptable

3 Junior

Un hash nu se poate inversa. Atunci cum poate cineva să afle PIN-ul de 4 cifre din sha256(pin)? Scrie codul.

Răspuns scurt: Nu inversează funcția, ci încearcă toate intrările posibile. Dacă spațiul intrărilor e mic (10.000 de PIN-uri), forța brută găsește valoarea instantaneu, oricât de bună ar fi funcția hash.

Rezistența la preimagine spune că, dat fiind un hash, nu poți calcula intrarea mai repede decât încercând. Dar „încercând” e simplu când există puține intrări posibile:

PYTHON
import hashlib

target = hashlib.sha256(b"4821").hexdigest()

for n in range(10_000):
    guess = f"{n:04d}".encode()
    if hashlib.sha256(guess).hexdigest() == target:
        print("PIN găsit:", guess.decode())
        break

Codul nu „sparge” SHA-256, doar enumeră spațiul de căutare. Securitatea unui hash depinde deci și de entropia intrării, nu doar de algoritm.

Consecințe practice în blockchain:

  • o cheie privată este un număr aleator de 256 de biți tocmai ca spațiul să fie imposibil de enumerat;
  • „brain wallet”-urile, în care cheia era derivată din hash-ul unei fraze alese de om, au fost golite sistematic, pentru că frazele umane sunt previzibile;
  • o schemă commit-reveal cu o valoare mică (de exemplu un vot „da/nu”) trebuie să includă un salt aleator, altfel oricine calculează cele două hash-uri posibile.

Pentru parole se folosesc funcții lente, cu salt (bcrypt, scrypt, Argon2), care fac fiecare încercare costisitoare. SHA-256 e intenționat rapid, deci nu e potrivit singur pentru parole.

Ce urmărește intervievatorul: Verifică dacă înțelegi că „ireversibil” nu înseamnă „imposibil de ghicit”. Greșeala tipică este să crezi că orice hash ascunde intrarea, indiferent cât de mică este.

4 Junior

Scrie o funcție sha256d care calculează double SHA-256 ca în Bitcoin. Unde se folosește și de ce nu e același lucru cu sha256(sha256(x).hexdigest())?

Răspuns scurt: sha256d(x) = sha256(sha256(x).digest()).digest(). Bitcoin îl folosește pentru hash-ul antetului de bloc, txid, nodurile arborelui Merkle și checksum-ul Base58Check. Al doilea hash se aplică pe cei 32 de bytes, nu pe textul hex.

PYTHON
import hashlib

def sha256d(data: bytes) -> bytes:
    return hashlib.sha256(hashlib.sha256(data).digest()).digest()

print(sha256d(b"hello").hex())

Funcția primește bytes și întoarce bytes. Al doilea SHA-256 se aplică pe cei 32 de bytes ai primului rezultat. Dacă l-ai aplica pe hexdigest(), ai hash-ui un șir de 64 de caractere ASCII, adică alte date, și rezultatul n-ar mai corespunde cu nimic din Bitcoin.

Unde apare în Bitcoin:

  • hash-ul blocului: double SHA-256 pe antetul de 80 de bytes; asta e valoarea comparată cu ținta la minare;
  • txid: double SHA-256 pe tranzacția serializată (fără date witness, după SegWit);
  • arborele Merkle: fiecare nod este sha256d(stânga + dreapta);
  • checksum-ul adreselor Base58Check: primii 4 bytes din sha256d(payload).

De ce dublu? Satoshi nu a explicat alegerea. O explicație des citată este protecția împotriva atacului de extindere a lungimii (length extension), la care SHA-256 simplu e vulnerabil în anumite construcții. Pentru adrese, Bitcoin folosește altă combinație: RIPEMD160(SHA256(x)), numită HASH160.

În interviu merită să spui că Ethereum nu folosește SHA-256d, ci Keccak-256, deci codul nu e portabil între rețele.

Ce urmărește intervievatorul: Se verifică lucrul corect cu bytes și cunoașterea locurilor unde apare hash-ul dublu. Mulți candidați cred că „dublu” crește securitatea de două ori.

Eroarea, în practică:can only concatenate str (not "bytes") to strcan't concat str to bytes

5 Junior

Care e diferența dintre un hash, o criptare și o codare precum Base64? Care dintre ele se folosește la un blockchain public și pentru ce?

Răspuns scurt: Hash-ul e o amprentă ireversibilă, de lungime fixă. Criptarea e reversibilă cu o cheie și ascunde conținutul. Codarea (Base64, hex, Base58) doar schimbă reprezentarea, fără nicio securitate. Blockchain-urile publice folosesc hash-uri și semnături, nu criptare.

Trei operații care sunt des confundate:

  • hash (SHA-256, Keccak-256): ia orice intrare și produce o valoare de lungime fixă. Nu există cheie și nu există drum înapoi. Servește la integritate și identificare: dacă datele se schimbă, se schimbă amprenta.
  • criptare (AES, ChaCha20, RSA): transformă datele astfel încât doar cine are cheia să le poată citi. E reversibilă prin definiție. Servește la confidențialitate.
  • codare (Base64, hex, Base58): o reprezentare diferită a acelorași bytes, reversibilă de oricine, fără cheie. Servește la transport și lizibilitate.

Pe un blockchain public, datele nu sunt criptate: oricine poate citi orice tranzacție. Ce garantează sistemul este integritatea (prin hash-uri înlănțuite și arbori Merkle) și autorizarea (prin semnături digitale). Criptografia cu cheie publică e folosită aici pentru semnare, nu pentru a ascunde mesaje.

Base58 apare în adresele Bitcoin, iar hex în aproape toate interfețele, dar ambele sunt doar forme de afișare. Dacă un candidat spune că „adresa e criptată în Base58”, e un semnal de alarmă.

Confidențialitatea pe blockchain se obține cu alte tehnici, de exemplu dovezi zero-knowledge (Zcash) sau rețele private cu acces controlat, nu cu simpla criptare a datelor puse în bloc.

Ce urmărește intervievatorul: Verifică vocabularul de bază. Greșeala tipică este „tranzacțiile sunt criptate pe blockchain”, care arată că nu ai înțeles rolul semnăturilor.

Eroarea, în practică:binascii.Error: Incorrect padding

6 Junior

Scrie o funcție merkle_root(hashes) care calculează rădăcina arborelui Merkle în stilul Bitcoin, pentru o listă de hash-uri de tranzacții.

Răspuns scurt: Combini hash-urile două câte două cu sha256d(stânga + dreapta) până rămâne unul singur. Când un nivel are număr impar de elemente, Bitcoin duplică ultimul element.

PYTHON
import hashlib

def sha256d(b: bytes) -> bytes:
    return hashlib.sha256(hashlib.sha256(b).digest()).digest()

def merkle_root(hashes: list[bytes]) -> bytes:
    if not hashes:
        raise ValueError("lista de tranzacții este goală")
    level = list(hashes)
    while len(level) > 1:
        if len(level) % 2 == 1:
            level.append(level[-1])
        level = [sha256d(level[i] + level[i + 1])
                 for i in range(0, len(level), 2)]
    return level[0]

Detalii care contează:

  • copiezi lista (list(hashes)) ca să nu modifici argumentul apelantului când adaugi duplicatul;
  • cu o singură tranzacție (doar coinbase), rădăcina este chiar hash-ul acelei tranzacții;
  • la fiecare nivel lista se înjumătățește, deci sunt aproximativ log2(n) niveluri și n - 1 operații de hash în total;
  • în Bitcoin real, hash-urile se concatenează în ordinea internă a bytes-ilor, nu în ordinea inversată afișată de exploratoare.

Rădăcina Merkle intră în antetul blocului. Astfel, antetul de 80 de bytes „angajează” toate tranzacțiile: orice modificare a unei tranzacții schimbă rădăcina, deci hash-ul antetului, deci invalidează Proof of Work.

Dacă intervievatorul întreabă ce problemă are duplicarea ultimului element, răspunsul este vulnerabilitatea CVE-2012-2459: două liste diferite pot da aceeași rădăcină.

Ce urmărește intervievatorul: Este o întrebare clasică de cod live la interviurile de blockchain. Se pierd puncte pe cazul impar, pe lista goală și pe modificarea accidentală a listei primite.

Eroarea, în practică:IndexError: list index out of rangeRădăcina Merkle ignoră ultima tranzacție

7 Junior

Două dicționare Python egale dau hash-uri diferite când le serializezi cu json.dumps. De ce și cum previi problema într-un blockchain scris în Python?

PYTHON
import hashlib, json

a = {"from": "ana", "to": "dan", "amount": 5}
b = {"to": "dan", "amount": 5, "from": "ana"}
print(a == b)
print(hashlib.sha256(json.dumps(a).encode()).hexdigest() ==
      hashlib.sha256(json.dumps(b).encode()).hexdigest())

Răspuns scurt: Afișează True, apoi False. json.dumps păstrează ordinea de inserare a cheilor, deci șirurile diferă. Soluția este serializarea canonică: sort_keys=True și separatori fixați.

Din Python 3.7, dicționarele păstrează ordinea de inserare. a == b compară conținutul, deci e True, dar json.dumps scrie cheile în ordinea în care au fost puse, așa că cele două șiruri JSON sunt diferite. Hash-ul se calculează pe bytes, iar bytes diferiți dau hash-uri complet diferite.

Într-un blockchain, asta înseamnă că două noduri care primesc aceeași tranzacție, dar o reconstruiesc în ordine diferită, calculează hash-uri diferite și ajung să respingă blocuri valide.

Soluția este o serializare canonică, adică o singură reprezentare acceptată pentru aceleași date:

PYTHON
def canonical(obj) -> bytes:
    return json.dumps(obj, sort_keys=True,
                      separators=(",", ":"),
                      ensure_ascii=False).encode()
  • sort_keys=True fixează ordinea cheilor;
  • separators elimină spațiile, care altfel depind de opțiuni;
  • atenție la float: 0.1 + 0.2 se serializează ca 0.30000000000000004, de aceea sumele se țin ca întregi (satoshi).

Bitcoin și Ethereum nu folosesc JSON pentru hash-uri, ci formate binare stricte: serializarea Bitcoin cu câmpuri de lungime fixă, respectiv RLP și SSZ în Ethereum. JSON apare doar în API-urile RPC. În proiectele didactice însă, JSON canonic este compromisul corect.

Ce urmărește intervievatorul: Verifică dacă înțelegi că hash-ul depinde de bytes, nu de „sensul” datelor. Bug-ul apare des în proiectele de curs și e greu de depanat dacă nu știi să-l cauți.

Eroarea, în practică:Hash diferit: ordinea cheilor în JSON

8 Mid

Ce este paradoxul zilei de naștere și de ce spunem că SHA-256 oferă aproximativ 128 de biți de securitate împotriva coliziunilor, nu 256?

Răspuns scurt: Într-un spațiu cu N valori posibile, o coliziune apare după aproximativ radical din N încercări. Pentru 2^256 ieșiri, asta înseamnă circa 2^128 încercări, deci securitatea la coliziuni este de 128 de biți.

Paradoxul zilei de naștere: într-o grupă de 23 de oameni, probabilitatea ca doi să aibă aceeași zi de naștere depășește 50%, deși există 365 de zile. Motivul este că nu cauți o anumită zi, ci orice pereche care se potrivește, iar numărul de perechi crește cu pătratul numărului de oameni.

Pentru o funcție hash cu ieșire de n biți:

  • preimagine (găsești o intrare pentru un hash dat): circa 2^n încercări;
  • coliziune (găsești oricare două intrări cu același hash): circa 2^(n/2) încercări.

Pentru SHA-256, coliziunea costă în jur de 2^128 operații, ceea ce rămâne cu mult peste orice putere de calcul disponibilă. De aceea se spune că SHA-256 are 128 de biți de securitate la coliziuni.

Poți verifica fenomenul pe un hash trunchiat:

PYTHON
import hashlib, os

seen = {}
tries = 0
while True:
    x = os.urandom(16)
    h = hashlib.sha256(x).digest()[:3]   # doar 24 de biți
    tries += 1
    if h in seen and seen[h] != x:
        print("coliziune după", tries, "încercări")
        break
    seen[h] = x

Cu 24 de biți, coliziunea apare de obicei după câteva mii de încercări, nu după milioane. Aceeași logică explică de ce HASH160 din adresele Bitcoin (160 de biți) are o securitate la coliziuni de circa 80 de biți, relevantă la adresele multisig, motiv pentru care P2WSH folosește SHA-256 pe 32 de bytes.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre preimagine și coliziune în termeni de cost. Mulți candidați spun că ambele cer 2^256 încercări.

9 Mid

De ce hash-ul unei tranzacții calculat în Python nu seamănă cu txid-ul afișat de un explorer de blocuri, deși ai serializat corect tranzacția?

Răspuns scurt: Bitcoin afișează txid-ul și hash-ul blocului cu bytes-ii în ordine inversă față de rezultatul brut al sha256d. Trebuie să inversezi: sha256d(raw)[::-1].hex().

Intern, Bitcoin tratează rezultatul double SHA-256 ca pe un număr de 256 de biți stocat în format little-endian (cel mai puțin semnificativ byte primul). Când îl afișează, interfețele (Bitcoin Core, exploratoarele) îl scriu ca număr obișnuit, cu cel mai semnificativ byte primul. Rezultatul: șirul hex afișat este inversat byte cu byte față de ce întoarce hashlib.

PYTHON
import hashlib

def sha256d(b: bytes) -> bytes:
    return hashlib.sha256(hashlib.sha256(b).digest()).digest()

raw_tx = bytes.fromhex("0100...")  # tranzacția serializată, fără date witness
internal = sha256d(raw_tx)
txid = internal[::-1].hex()        # ce vezi în explorer

Inversarea se face pe bytes, nu pe caractere: internal.hex()[::-1] ar inversa și cele două cifre din fiecare byte și ar da un rezultat greșit.

Același lucru apare la hash-ul blocului. De aceea hash-urile de bloc afișate încep cu multe zerouri: zerourile sunt de fapt bytes-ii de la sfârșitul valorii brute, cei mai semnificativi în interpretarea little-endian, iar condiția de minare cere ca numărul să fie mic.

Alte capcane înrudite:

  • în arborele Merkle și în câmpul prev_hash din antet se folosește ordinea internă, nu cea afișată;
  • după SegWit, txid-ul exclude datele witness, iar wtxid le include;
  • câmpurile numerice din antet (version, time, bits, nonce) sunt și ele little-endian.

Ce urmărește intervievatorul: Este o întrebare care separă oamenii care au lucrat cu date reale de cei care au citit doar teorie. Greșeala tipică este inversarea șirului hex caracter cu caracter.

Eroarea, în practică:byteorder must be either 'little' or 'big'

10 Mid

Scrie o funcție care produce dovada Merkle pentru tranzacția de la indexul i și una care o verifică față de rădăcină. Câte hash-uri conține dovada?

Răspuns scurt: Dovada conține, pentru fiecare nivel, hash-ul vecinului și partea pe care se află, adică aproximativ log2(n) hash-uri. Verificarea refăcând drumul până la rădăcină cere tot atâtea operații.

PYTHON
def merkle_proof(hashes: list[bytes], index: int):
    proof, level = [], list(hashes)
    while len(level) > 1:
        if len(level) % 2 == 1:
            level.append(level[-1])
        sibling = index ^ 1                 # vecinul din pereche
        proof.append((level[sibling], sibling < index))
        level = [sha256d(level[k] + level[k + 1])
                 for k in range(0, len(level), 2)]
        index //= 2
    return proof

def verify_proof(leaf: bytes, proof, root: bytes) -> bool:
    h = leaf
    for sibling, sibling_is_left in proof:
        h = sha256d(sibling + h) if sibling_is_left else sha256d(h + sibling)
    return h == root

index ^ 1 dă vecinul: pentru un index par, cel din dreapta; pentru unul impar, cel din stânga. La urcare, indexul se împarte la 2. Partea vecinului trebuie păstrată, pentru că sha256d(a + b) diferă de sha256d(b + a).

Pentru un bloc cu 4.000 de tranzacții, dovada are 12 hash-uri, adică sub 400 de bytes, în loc de toate tranzacțiile. Pe asta se bazează nodurile ușoare (SPV): descarcă doar antetele blocurilor și cer dovezi Merkle pentru tranzacțiile care le interesează.

Limitarea: dovada arată că tranzacția este inclusă în bloc, nu că este validă. Validitatea o garantează consensul, adică presupunerea că blocurile cu Proof of Work au fost verificate de noduri complete.

Ce urmărește intervievatorul: Se verifică înțelegerea structurii arborelui și scrierea de cod corect cu indici. Cel mai des se uită ordinea concatenării sau duplicarea ultimului element.

Eroarea, în practică:IndexError: list index out of rangeDovada Merkle pică: stânga / dreapta inversate

11 Senior

Ce este vulnerabilitatea CVE-2012-2459 din arborele Merkle al Bitcoin și ce lecție de design scoți din ea?

Răspuns scurt: Bitcoin duplică ultimul element la număr impar, deci [a, b, c] și [a, b, c, c] au aceeași rădăcină. Un atacator putea face un nod să marcheze ca invalid un bloc valid. Lecția: o structură Merkle trebuie să fie neambiguă.

Regula de duplicare face ca merkle_root([a, b, c]) să calculeze de fapt merkle_root([a, b, c, c]). Deci există două liste diferite de tranzacții cu aceeași rădăcină, adică cu același antet de bloc și același Proof of Work.

Atacul descris în 2012: un atacator ia un bloc valid, îi construiește varianta cu o tranzacție duplicată (care e invalidă, pentru că aceeași tranzacție apare de două ori) și o trimite unui nod. Nodul validează, găsește dublura, respinge blocul și memorează hash-ul lui ca invalid. Când primește apoi blocul corect, cu același hash, îl respinge direct. Rezultatul: nodul rămâne blocat pe un lanț vechi, un fel de denial of service.

Corecția din Bitcoin Core a fost să nu marcheze ca invalid permanent un bloc dacă respingerea vine dintr-o astfel de mutație, plus detectarea explicită a perechilor identice la sfârșitul unui nivel.

Lecții de design pentru propriile structuri Merkle:

  • separarea domeniilor: hash-ul unei frunze și al unui nod intern trebuie să folosească prefixe diferite (de exemplu 0x00 pentru frunză și 0x01 pentru nod intern, ca în RFC 6962 pentru Certificate Transparency); altfel un nod intern poate fi prezentat drept frunză (atac de a doua preimagine);
  • rădăcina ar trebui să angajeze și numărul de frunze;
  • nu leagă „invalid” de un identificator care nu acoperă toate datele.

Ce urmărește intervievatorul: Întrebarea apare la roluri de protocol sau audit. Verifică dacă înțelegi că o construcție corectă criptografic poate fi totuși vulnerabilă prin felul în care e folosită.

Eroarea, în practică:Rădăcina Merkle ignoră ultima tranzacție

12 Senior

Ce este atacul de extindere a lungimii (length extension) la SHA-256 și de ce sha256(secret + mesaj) nu este un MAC sigur?

Răspuns scurt: SHA-256 are construcție Merkle–Damgård: din sha256(secret + m) și lungimea secretului poți calcula sha256(secret + m + padding + extra) fără să știi secretul. Pentru autentificare folosești HMAC, nu concatenarea simplă.

SHA-256 procesează mesajul în blocuri de 64 de bytes și ține o stare internă de 256 de biți. Hash-ul final este chiar această stare după ultimul bloc, care conține padding-ul și lungimea mesajului. Deci dacă știi rezultatul, știi starea internă și poți continua procesarea cu blocuri noi, ca și cum ai fi avut mesajul inițial.

Concret, un server care autentifică cereri cu tag = sha256(secret + "amount=10") este vulnerabil: atacatorul, fără secret, poate produce un tag valid pentru "amount=10" + padding + "&amount=1000", dacă ghicește lungimea secretului. Atacul a fost exploatat real în API-uri web.

Soluțiile:

  • HMAC (hmac.new(key, msg, hashlib.sha256) în Python), care aplică hash-ul de două ori cu cheia amestecată în moduri diferite;
  • funcții fără această proprietate: SHA-3/Keccak (construcție sponge), BLAKE2, BLAKE3;
  • double SHA-256, care ascunde starea internă a primului hash.
PYTHON
import hmac, hashlib

tag = hmac.new(b"cheie-secreta", b"amount=10", hashlib.sha256).hexdigest()
ok = hmac.compare_digest(tag, tag_primit)

compare_digest compară în timp constant, ca să nu scurgi informație prin timpul de răspuns.

În Bitcoin, atacul nu afectează direct consensul, pentru că hash-urile nu sunt folosite ca MAC cu secret. Dar contează în infrastructura din jur: API-uri de exchange, webhooks de plăți, servicii de custodie.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum este construită funcția hash, nu doar proprietățile ei. Greșeala tipică este presupunerea că orice hash cu un secret în față e o semnătură sigură.

Eroarea, în practică:Missing required argument 'digestmod'

Chei, curbe eliptice și semnături

13 Junior

Ce afișează codul de mai jos? Explică ce este un invers modular și de ce apare peste tot în criptografia cu curbe eliptice.

PYTHON
print((5 * 3) % 7, pow(3, -1, 7), -3 % 7)

Răspuns scurt: Afișează 1 5 4. pow(3, -1, 7) este inversul lui 3 modulo 7, adică numărul care înmulțit cu 3 dă 1 modulo 7. Pe curbele eliptice nu există împărțire obișnuită, ci înmulțire cu inversul modular.

Aritmetica modulară este „aritmetica ceasului”: după ce ajungi la modul, o iei de la zero.

  • (5 * 3) % 7: 15 împărțit la 7 dă rest 1.
  • pow(3, -1, 7): căutăm x astfel încât 3 * x % 7 == 1. Cum 3 * 5 = 15, iar 15 % 7 = 1, inversul este 5. Forma cu exponent -1 există din Python 3.8; înainte se folosea algoritmul lui Euclid extins sau pow(3, 7 - 2, 7) (mica teoremă a lui Fermat, valabilă când modulul e prim).
  • -3 % 7: în Python, rezultatul are semnul împărțitorului, deci 4. În C sau Java, -3 % 7 dă -3, o capcană clasică la portarea codului.

De ce contează: pe o curbă eliptică peste un corp finit, toate coordonatele sunt numere modulo un prim p. Formula pantei la adunarea punctelor cere o împărțire, care devine înmulțire cu inversul:

PYTHON
m = (y2 - y1) * pow(x2 - x1, -1, p) % p

În ECDSA, s = k^-1 * (z + r * d) mod n folosește inversul nonce-ului modulo ordinul curbei.

Inversul există doar dacă numărul și modulul sunt prime între ele. De aceea modulii folosiți sunt numere prime, iar valoarea 0 nu are invers, caz care trebuie tratat separat în cod.

Ce urmărește intervievatorul: Verifică fundamentul matematic al cursului și o capcană practică: semnul operatorului % diferă între limbaje. Candidații uită adesea că pow cu exponent negativ cere Python 3.8+.

Eroarea, în practică:base is not invertible for the given moduluspow() 3rd argument not allowed unless all integers

14 Junior

De ce poți calcula ușor cheia publică dintr-o cheie privată, dar nu și invers? Ce problemă matematică stă la baza acestei asimetrii?

Răspuns scurt: Cheia publică este Q = d · G, o înmulțire scalară rapidă prin dublări și adunări. Găsirea lui d din Q și G este problema logaritmului discret pe curbe eliptice (ECDLP), pentru care nu se cunoaște un algoritm eficient.

Pe o curbă eliptică poți aduna două puncte și obții tot un punct al curbei. Înmulțirea scalară d · G înseamnă să aduni punctul generator G cu el însuși de d ori.

Direcția ușoară: nu faci d adunări, ci folosești algoritmul double-and-add. Pentru un d de 256 de biți ai nevoie de aproximativ 256 de dublări și cel mult 256 de adunări, deci calculul durează microsecunde.

Direcția grea: dat fiind Q și G, să găsești d. Punctele rezultate nu păstrează nicio ordine vizibilă; 5 · G nu e „lângă” 6 · G în vreun sens util. Cei mai buni algoritmi generici cunoscuți (baby-step giant-step, Pollard rho) au nevoie de circa 2^128 operații pentru o curbă de 256 de biți. Asta este ECDLP.

Analogia din curs: e ușor să amesteci culori, greu să le separi. Sau un ceas: dacă știi de câte ori a fost rotit acul, afli poziția imediat; dacă vezi doar poziția finală după miliarde de rotiri, nu poți afla numărul lor.

Consecințe:

  • cheia publică poate fi făcută publică fără risc;
  • securitatea depinde de alegerea aleatoare a lui d; un d mic sau previzibil se găsește prin forță brută;
  • un calculator cuantic suficient de mare ar rezolva ECDLP cu algoritmul lui Shor, motiv pentru care există cercetare în criptografia post-cuantică.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce cheia publică e sigură de publicat. Răspunsurile slabe repetă „e matematică grea” fără să numească problema sau algoritmul double-and-add.

15 Junior

Ce este curba secp256k1? Care sunt parametrii ei principali și ce valori poate avea o cheie privată Bitcoin?

Răspuns scurt: Este curba y² = x³ + 7 peste corpul finit modulo p = 2^256 − 2^32 − 977, cu un punct generator G fix și ordinul n al lui G. O cheie privată este orice număr întreg între 1 și n − 1.

secp256k1 este definită în standardul SEC 2 și a fost aleasă de Satoshi pentru Bitcoin; o folosește și Ethereum. Parametrii:

  • ecuația y² = x³ + a·x + b cu a = 0 și b = 7;
  • p = 2^256 − 2^32 − 977, primul modulo care se fac toate calculele cu coordonate;
  • G, punctul generator, cu coordonate fixate în standard;
  • n, ordinul lui G: cel mai mic număr pentru care n · G este punctul de la infinit; n este puțin mai mic decât 2^256;
  • cofactorul h = 1, deci toate punctele curbei sunt în subgrupul generat de G.
PYTHON
P = 2**256 - 2**32 - 977

def on_curve(x: int, y: int) -> bool:
    return (y * y - (x * x * x + 7)) % P == 0

Cheia privată este un număr d în intervalul [1, n − 1]. Valoarea 0 și valorile mai mari sau egale cu n sunt invalide. Cheia publică este punctul d · G.

De ce secp256k1 și nu curba NIST P-256 (secp256r1)? Parametrii lui secp256k1 sunt aleși într-un mod simplu și explicabil (o curbă de tip Koblitz), nu din valori aparent aleatoare greu de verificat. Forma a = 0 permite și optimizări de calcul.

O capcană în cod: nu genera cheia cu random, care nu este criptografic sigur. Folosește secrets.randbelow(n - 1) + 1 sau biblioteci consacrate.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat cu curba concret. Greșelile tipice sunt confuzia dintre p și n și generarea cheii cu modulul random.

Eroarea, în practică:Punct valid respins: curba verificată fără % p

16 Junior

Ce înseamnă o cheie publică comprimată pe secp256k1 și cum o obții în Python din punctul (x, y)?

Răspuns scurt: Forma necomprimată are 65 de bytes: prefixul 04, apoi x și y. Forma comprimată are 33 de bytes: prefixul 02 dacă y e par sau 03 dacă e impar, apoi doar x, pentru că y se poate recalcula din ecuația curbei.

Pentru un x dat, ecuația y² = x³ + 7 are două soluții modulo p: y și p − y. Cum p e impar, una dintre ele e pară și cealaltă impară. Deci e suficient să păstrezi x și un bit de paritate.

PYTHON
P = 2**256 - 2**32 - 977

def compress(point) -> bytes:
    x, y = point
    return bytes([2 + (y & 1)]) + x.to_bytes(32, "big")

def decompress(data: bytes):
    prefix, x = data[0], int.from_bytes(data[1:], "big")
    y = pow(x**3 + 7, (P + 1) // 4, P)   # rădăcina pătrată modulo P
    if (y & 1) != (prefix & 1):
        y = P - y
    return x, y

Rădăcina pătrată se calculează cu exponentul (P + 1) // 4, formula valabilă pentru că P % 4 == 3 la secp256k1.

De ce contează:

  • adresele Bitcoin vechi foloseau cheia necomprimată; cheia comprimată dă alt HASH160, deci altă adresă pentru aceeași cheie privată. Un wallet care importă cheia trebuie să știe ce formă a fost folosită (formatul WIF are un indicator pentru asta);
  • SegWit cere chei comprimate în ieșirile P2WPKH standard;
  • Taproot (BIP340) merge mai departe și folosește doar x, în 32 de bytes;
  • Ethereum calculează adresa din forma necomprimată fără prefix (64 de bytes).

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre geometria curbei și formatul pe fir. Candidații uită că aceeași cheie privată poate genera două adrese Bitcoin diferite.

17 Junior

Scrie o funcție care verifică dacă o adresă Bitcoin în format Base58Check are checksum-ul corect. De ce s-a ales Base58 și nu Base64?

Răspuns scurt: Decodezi șirul din Base58 în bytes, separi ultimii 4 bytes ca checksum și îi compari cu primii 4 bytes din sha256d(restul). Base58 elimină caracterele ușor de confundat (0, O, I, l) și semnele + și /.

PYTHON
import hashlib

ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

def b58decode(s: str) -> bytes:
    n = 0
    for ch in s:
        n = n * 58 + ALPHABET.index(ch)   # ValueError la caracter invalid
    raw = n.to_bytes((n.bit_length() + 7) // 8, "big")
    pad = len(s) - len(s.lstrip("1"))     # fiecare "1" de la început = un byte 0
    return bytes(pad) + raw

def checksum_ok(address: str) -> bool:
    data = b58decode(address)
    payload, check = data[:-4], data[-4:]
    digest = hashlib.sha256(hashlib.sha256(payload).digest()).digest()
    return digest[:4] == check

Detaliul care se uită cel mai des: zerourile de la început. Conversia la număr le pierde, așa că Base58Check codează fiecare byte 0x00 inițial ca un caracter 1. De aceea adresele P2PKH de pe mainnet încep cu 1: primul byte (versiunea) este 0x00.

De ce Base58:

  • alfabetul elimină 0, O, I și l, care se confundă vizual când copiezi de mână;
  • nu are + și /, deci adresa se selectează cu dublu-clic și nu se strică în URL-uri;
  • checksum-ul de 4 bytes face ca o greșeală de tastare să fie detectată aproape sigur înainte să trimiți bani.

Adresele SegWit (încep cu bc1) folosesc alt format, Bech32 (BIP173) și Bech32m (BIP350, pentru Taproot), care poate și localiza anumite erori.

Ce urmărește intervievatorul: Este o întrebare de cod din materia cursului și verifică atenția la detalii. Cei mai mulți candidați uită tratarea caracterelor 1 de la început.

Eroarea, în practică:ValueError: substring not foundBase58 pierde „1” de la început

18 Mid

Scrie adunarea a două puncte pe o curbă eliptică peste un corp finit. Ce cazuri speciale trebuie tratate?

Răspuns scurt: Calculezi panta m, apoi x3 = m² − x1 − x2 și y3 = m(x1 − x3) − y1, totul modulo p. Cazurile speciale: punctul de la infinit (elementul neutru), puncte opuse (rezultatul e infinitul) și dublarea, când panta e tangenta.

PYTHON
P = 2**256 - 2**32 - 977   # secp256k1
A = 0                       # coeficientul a din y² = x³ + a·x + b

def point_add(p1, p2):
    if p1 is None:          # None = punctul de la infinit
        return p2
    if p2 is None:
        return p1
    x1, y1 = p1
    x2, y2 = p2
    if x1 == x2 and (y1 + y2) % P == 0:
        return None         # P + (−P) = infinit
    if p1 == p2:
        m = (3 * x1 * x1 + A) * pow(2 * y1, -1, P) % P
    else:
        m = (y2 - y1) * pow(x2 - x1, -1, P) % P
    x3 = (m * m - x1 - x2) % P
    y3 = (m * (x1 - x3) - y1) % P
    return (x3, y3)

Geometric, peste numere reale: duci dreapta prin cele două puncte, iei al treilea punct de intersecție cu curba și îl reflecți față de axa x. Peste un corp finit formulele rămân aceleași, cu împărțirea înlocuită de inversul modular.

Cazurile speciale:

  • punctul de la infinit joacă rolul lui 0: P + O = P;
  • puncte opuse (x, y) și (x, −y): dreapta e verticală, rezultatul este infinitul. Verificarea trebuie făcută înainte de a calcula inversul lui x2 − x1, care ar fi 0;
  • dublarea: dacă punctele coincid, panta este derivata, (3x² + a) / 2y. Cazul y = 0 e acoperit de verificarea punctelor opuse.

Codul este didactic: nu rulează în timp constant, deci nu e potrivit pentru chei reale.

Ce urmărește intervievatorul: Se verifică dacă ai implementat cu adevărat matematica din curs. Omisiunea tipică este cazul punctelor opuse, care provoacă o eroare la inversul lui 0.

Eroarea, în practică:cannot unpack non-iterable NoneType objectPunct valid respins: curba verificată fără % p

19 Mid

Scrie înmulțirea scalară k · G cu algoritmul double-and-add. De ce nu folosești o buclă cu k adunări și de ce codul tău nu e sigur pentru chei reale?

Răspuns scurt: Parcurgi biții lui k: la fiecare pas dublezi punctul curent și, dacă bitul e 1, îl adaugi la rezultat. Faci astfel circa 256 de dublări în loc de un număr astronomic de adunări. Varianta simplă scurge informație prin timpul de execuție.

PYTHON
def scalar_mult(k: int, point):
    result = None            # punctul de la infinit
    addend = point
    while k:
        if k & 1:
            result = point_add(result, addend)
        addend = point_add(addend, addend)
        k >>= 1
    return result

# cheia publică: Q = scalar_mult(d, G)

Algoritmul se bazează pe scrierea în binar a lui k. De exemplu, 13 = 8 + 4 + 1, deci 13 · G = 8G + 4G + G. Puterile lui 2 (G, 2G, 4G, 8G) se obțin prin dublări succesive, iar adunarea se face doar pentru biții de 1. Pentru un k de 256 de biți: cel mult 256 de dublări și 256 de adunări.

O buclă cu k adunări ar cere până la 2^256 operații, mai mult decât s-ar putea executa vreodată. Tocmai această diferență dintre direcția rapidă (double-and-add) și lipsa unui algoritm rapid pentru direcția inversă face ca schema să fie sigură.

De ce codul nu e potrivit pentru producție:

  • timpul depinde de biții cheii: ramura if k & 1 face o adunare în plus pentru fiecare bit de 1. Un atacator care măsoară timpul sau consumul de energie poate deduce biți din cheie (atac side-channel);
  • implementările reale folosesc tehnici în timp constant (Montgomery ladder, tabele precalculate cu acces uniform) și coordonate proiective, care evită inversul modular la fiecare pas.

În Bitcoin Core, toate acestea sunt în biblioteca libsecp256k1.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi algoritmul și complexitatea lui, plus conștiința riscurilor de implementare. Puțini candidați menționează atacurile prin timp.

20 Mid

Descrie pașii de semnare și de verificare ECDSA. Scrie funcțiile sign și verify folosind point_add și scalar_mult.

Răspuns scurt: Semnare: alegi un k secret și unic, r = (k·G).x mod n, s = k⁻¹(z + r·d) mod n. Verificare: w = s⁻¹, X = (z·w)·G + (r·w)·Q, iar semnătura e validă dacă X.x mod n == r.

Notații: d cheia privată, Q = d·G cheia publică, n ordinul lui G, z hash-ul mesajului ca număr.

PYTHON
import hashlib, secrets

def h(msg: bytes) -> int:
    return int.from_bytes(hashlib.sha256(msg).digest(), "big") % N

def sign(d: int, msg: bytes):
    z = h(msg)
    while True:
        k = secrets.randbelow(N - 1) + 1
        r = scalar_mult(k, G)[0] % N
        s = pow(k, -1, N) * (z + r * d) % N
        if r and s:
            return r, s

def verify(Q, msg: bytes, sig) -> bool:
    r, s = sig
    if not (1 <= r < N and 1 <= s < N):
        return False
    w = pow(s, -1, N)
    X = point_add(scalar_mult(h(msg) * w % N, G),
                  scalar_mult(r * w % N, Q))
    return X is not None and X[0] % N == r

De ce funcționează: z·w·G + r·w·Q = w(z + r·d)·G. Din formula lui s, w(z + r·d) = k, deci punctul obținut este exact k·G, a cărui coordonată x dă r.

Puncte de atenție:

  • verificarea intervalelor pentru r și s nu e opțională;
  • k trebuie să fie secret, uniform și niciodată refolosit. În practică se generează determinist din cheie și mesaj, după RFC 6979, ca să nu depinzi de un generator aleator bun;
  • Bitcoin semnează nu „mesajul”, ci un hash al tranzacției construit după reguli precise (sighash), iar Ethereum folosește Keccak-256 în loc de SHA-256.

Ce urmărește intervievatorul: Se verifică stăpânirea algoritmului central din curs și capacitatea de a-l justifica algebric. Mulți candidați omit verificarea intervalelor sau nu pot explica de ce verificarea dă r.

Eroarea, în practică:InvalidSignature: semnătura nu se verificăAcelași nonce k la două semnături ECDSA

21 Mid

Explică pas cu pas cum se obține o adresă Bitcoin P2PKH dintr-o cheie publică. De ce se publică un hash al cheii și nu cheia însăși?

Răspuns scurt: Calculezi HASH160 = RIPEMD160(SHA256(cheie_publică)), pui în față byte-ul de versiune 0x00, adaugi checksum-ul de 4 bytes din sha256d și codezi totul în Base58. Hash-ul scurtează adresa și ascunde cheia publică până la prima cheltuire.

PYTHON
import hashlib

def hash160(data: bytes) -> bytes:
    sha = hashlib.sha256(data).digest()
    return hashlib.new("ripemd160", sha).digest()

def p2pkh_address(pubkey: bytes) -> str:
    payload = bytes([0x00]) + hash160(pubkey)
    check = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    return b58encode(payload + check)

def b58encode(b: bytes) -> str:
    n = int.from_bytes(b, "big")
    out = ""
    while n:
        n, r = divmod(n, 58)
        out = ALPHABET[r] + out
    pad = len(b) - len(b.lstrip(bytes(1)))
    return "1" * pad + out

Notă practică: pe unele sisteme cu OpenSSL 3, hashlib.new("ripemd160") nu e disponibil implicit și ai nevoie de o implementare separată sau de o bibliotecă.

Pașii: cheia publică (33 de bytes comprimată) → SHA-256 → RIPEMD-160 (20 de bytes) → versiune 0x00 pentru mainnet (0x6f pentru testnet) → checksum → Base58.

De ce hash-ul cheii:

  • lungime: 20 de bytes în loc de 33 sau 65, deci o adresă mai scurtă și ieșiri mai mici;
  • un strat suplimentar de protecție: cheia publică apare pe lanț doar când cheltui din adresă. Până atunci, un atacator ar trebui să spargă și hash-ul, nu doar ECDLP. Argumentul e discutat des în contextul calculatoarelor cuantice;
  • de aceea se recomandă să nu refolosești adrese: după prima cheltuire, cheia publică e vizibilă.

Ethereum procedează diferit: adresa este ultimii 20 de bytes din Keccak-256 al cheii publice necomprimate, fără versiune și fără checksum în bytes.

Ce urmărește intervievatorul: Verifică dacă poți reconstitui un lanț de transformări fără să le amesteci ordinea. Greșelile tipice: uitarea byte-ului de versiune și confuzia dintre adresă și cheie publică.

Eroarea, în practică:Base58 pierde „1” de la începutChecksum Base58Check: SHA-256 simplu, nu dublu

22 Senior

Ce este maleabilitatea semnăturilor ECDSA? Arată de ce (r, n − s) este tot o semnătură validă și ce probleme a creat asta în Bitcoin.

Răspuns scurt: Dacă (r, s) e validă, e validă și (r, n − s). Un terț putea schimba semnătura, deci txid-ul tranzacției, fără s-o invalideze. Bitcoin a rezolvat prin regula low-S și prin SegWit, care scoate semnăturile din txid.

La verificare se calculează w = s⁻¹. Pentru s' = n − s, avem w' = −w mod n, deci punctul obținut este −(k·G). Punctul opus are aceeași coordonată x, deci aceeași valoare r, iar verificarea trece. Oricine vede semnătura poate produce varianta „oglindită” fără cheia privată.

Problema în Bitcoin: înainte de SegWit, txid-ul se calcula pe întreaga tranzacție, inclusiv semnăturile. Un nod rău-intenționat putea lua o tranzacție din mempool, să inverseze s și să o retransmită. Dacă varianta lui ajungea în bloc, tranzacția era executată, dar sub alt txid. Consecințe:

  • un serviciu care urmărea plata după txid credea că nu a fost confirmată și putea retrimite banii;
  • tranzacțiile construite peste una neconfirmată (de exemplu în canale de plată) se refereau la un txid care nu mai exista. De aceea Lightning a devenit practic posibil abia după SegWit.

Soluțiile:

  • low-S: Bitcoin Core acceptă ca standard doar semnături cu s ≤ n/2 (regulă de politică, BIP146 pentru SegWit); Ethereum impune aceeași regulă din EIP-2;
  • encodare DER strictă (BIP66, regulă de consens din 2015);
  • SegWit (BIP141): semnăturile stau în witness, care nu intră în txid;
  • Schnorr (BIP340) are o encodare fixă, fără această ambiguitate.

Lecția generală: nu identifica o operație după hash-ul unor date pe care altcineva le poate modifica.

Ce urmărește intervievatorul: Întrebarea arată dacă înțelegi legătura dintre un detaliu matematic și o problemă de protocol. Candidații slabi confundă maleabilitatea cu falsificarea semnăturii.

23 Senior

Ce se întâmplă dacă un wallet semnează două tranzacții diferite cu aceeași cheie și același nonce k ECDSA? Arată cum se recuperează cheia privată.

Răspuns scurt: Cheia privată se poate calcula din cele două semnături publice: k = (z1 − z2) / (s1 − s2) mod n, apoi d = (s1·k − z1) / r mod n. Refolosirea nonce-ului a dus la incidente reale, de la consola PS3 la wallet-uri Android.

Cu același k, ambele semnături au același r, deci refolosirea se vede direct pe lanț. Ecuațiile:

s1 = k⁻¹(z1 + r·d) și s2 = k⁻¹(z2 + r·d) (mod n)

Scăzând: s1 − s2 = k⁻¹(z1 − z2), deci k = (z1 − z2)(s1 − s2)⁻¹. Cu k cunoscut, din prima ecuație: d = (s1·k − z1)·r⁻¹.

PYTHON
def recover_private_key(r, s1, z1, s2, z2, n):
    k = (z1 - z2) * pow(s1 - s2, -1, n) % n
    return (s1 * k - z1) * pow(r, -1, n) % n

Toate valorile r, s și z sunt publice sau calculabile din tranzacții, deci oricine scanează lanțul poate găsi astfel de perechi. Există roboți care fac exact asta și golesc adresele afectate.

Incidente cunoscute:

  • Sony folosea un k constant pentru semnarea software-ului PS3, iar cheia a fost recuperată și prezentată public în 2010;
  • în 2013, o problemă a generatorului SecureRandom din Android a făcut ca unele wallet-uri Bitcoin să repete nonce-ul, iar fondurile au fost furate.

Chiar și un k parțial previzibil (câțiva biți ficși) permite recuperarea cheii cu atacuri pe latice, dacă ai multe semnături.

Apărarea: RFC 6979, care derivă k determinist din cheia privată și hash-ul mesajului. Același mesaj dă același k, mesaje diferite dau k diferit, fără dependență de un generator aleator. Bibliotecile mature o fac implicit; nu scrie propria semnare pentru chei reale.

Ce urmărește intervievatorul: Este o întrebare de senior pentru roluri de securitate sau wallet. Verifică dacă înțelegi că ECDSA e sigur doar în ipotezele lui și că erorile de implementare sunt fatale.

Eroarea, în practică:Același nonce k la două semnături ECDSA

24 Senior

Ce aduce semnătura Schnorr (BIP340, activată cu Taproot) față de ECDSA în Bitcoin?

Răspuns scurt: Schnorr are o formulă liniară, s = k + e·d, care permite agregarea cheilor și semnăturilor (MuSig2), verificarea în lot și o demonstrație de securitate mai curată. Semnăturile au fix 64 de bytes, nu sunt maleabile, iar cheile publice au 32 de bytes.

Schnorr folosește aceeași curbă, secp256k1, dar altă schemă:

  • semnare: R = k·G, e = hash(R || P || m), s = k + e·d mod n; semnătura este (R.x, s);
  • verificare: s·G == R + e·P.

Avantaje concrete:

  • liniaritate: dacă două persoane au cheile P1 și P2, pot produce împreună o semnătură validă pentru cheia agregată P1 + P2 (cu protocoale precum MuSig2, care evită atacul de anulare a cheilor). Pe lanț apare o singură cheie și o singură semnătură, deci un multisig arată ca o plată obișnuită: mai puțin spațiu, mai multă confidențialitate;
  • verificare în lot: un nod poate verifica multe semnături odată, mai rapid decât una câte una;
  • format fix: 64 de bytes, fără encodarea DER cu lungime variabilă a ECDSA și fără maleabilitatea s / n − s;
  • chei x-only: cheia publică are 32 de bytes, cu paritatea lui y fixată prin convenție;
  • securitatea are o demonstrație standard în modelul oracolului aleator, mai simplă decât la ECDSA.

De ce n-a folosit Satoshi Schnorr de la început? Schema a fost acoperită de un brevet până în 2008, iar ECDSA era standardizat și disponibil în biblioteci.

Taproot (BIP341, activat în noiembrie 2021) combină Schnorr cu arbori de scripturi (MAST): poți cheltui fie cu cheia agregată, fie dezvăluind doar ramura de script folosită. Nonce-ul rămâne la fel de critic ca la ECDSA.

Ce urmărește intervievatorul: Verifică dacă urmărești evoluția protocolului Bitcoin și înțelegi de ce proprietățile matematice au consecințe practice. Mulți candidați știu doar că „Taproot aduce confidențialitate”.

Blocuri, lanț și noduri

Exersează capitolul cu exerciții reale: Curs blockchain online →
25 Junior

Scrie o clasă Block în Python care își calculează hash-ul din câmpurile proprii și creează blocul geneză. Ce câmpuri trebuie să intre în hash?

Răspuns scurt: Hash-ul trebuie calculat dintr-o serializare canonică a tuturor câmpurilor care definesc blocul: index, timestamp, tranzacții, hash-ul blocului anterior și nonce. Blocul geneză are prev_hash format din zerouri, pentru că nu are predecesor.

PYTHON
import hashlib, json, time

class Block:
    def __init__(self, index, transactions, prev_hash, nonce=0, timestamp=None):
        self.index = index
        self.transactions = transactions
        self.prev_hash = prev_hash
        self.nonce = nonce
        self.timestamp = time.time() if timestamp is None else timestamp
        self.hash = self.compute_hash()

    def compute_hash(self) -> str:
        data = {
            "index": self.index,
            "transactions": self.transactions,
            "prev_hash": self.prev_hash,
            "nonce": self.nonce,
            "timestamp": self.timestamp,
        }
        raw = json.dumps(data, sort_keys=True, separators=(",", ":"))
        return hashlib.sha256(raw.encode()).hexdigest()

genesis = Block(0, [], "0" * 64, timestamp=0)

Fiecare câmp care poate fi modificat trebuie să intre în hash. Dacă lași timestamp afară, cineva poate schimba ora blocului fără să invalideze nimic. Dacă lași nonce afară, minarea nu poate funcționa, pentru că schimbarea lui nu schimbă hash-ul.

hash nu intră în propriul calcul, evident. El e păstrat ca atribut doar pentru comoditate; un nod care primește blocul trebuie să-l recalculeze, nu să-l creadă.

Blocul geneză este singurul fără predecesor. În Bitcoin e scris direct în codul sursă al fiecărui nod, cu valorile fixe din 3 ianuarie 2009. Toate nodurile pornesc de la același geneză, altfel ar fi rețele diferite. De aceea în exemplu timestamp=0 este fixat: două noduri care creează geneza separat trebuie să obțină același hash.

Ce urmărește intervievatorul: Este punctul de plecare al proiectului din curs. Se verifică dacă știi ce trebuie să acopere hash-ul și de ce geneza trebuie să fie identică pe toate nodurile.

Eroarea, în practică:Lanț invalid după modificarea unui blocCâmpul hash inclus în propriul hash

26 Junior

Scrie funcția is_chain_valid(chain, difficulty). Ce verificări face și ce atac ar fi posibil dacă lipsește oricare dintre ele?

Răspuns scurt: Pentru fiecare bloc verifici că hash-ul salvat e egal cu cel recalculat, că respectă dificultatea și că prev_hash coincide cu hash-ul blocului anterior. Fără oricare dintre ele, un atacator poate modifica date sau poate lipi blocuri fără muncă.

PYTHON
def is_chain_valid(chain, difficulty: int, genesis_hash: str) -> bool:
    if not chain or chain[0].hash != genesis_hash:
        return False
    prefix = "0" * difficulty
    for i in range(1, len(chain)):
        block, prev = chain[i], chain[i - 1]
        if block.hash != block.compute_hash():
            return False          # conținut modificat după minare
        if not block.hash.startswith(prefix):
            return False          # bloc fără Proof of Work
        if block.prev_hash != prev.hash:
            return False          # legătură ruptă
        if block.index != prev.index + 1:
            return False
    return True

Ce prinde fiecare verificare:

  • hash recalculat: cineva a schimbat o tranzacție, dar a lăsat hash-ul vechi. Fără verificare, lanțul ar arăta intact;
  • dificultate: cineva a modificat blocul și a recalculat hash-ul, dar fără să mineze. Fără verificare, rescrierea istoriei nu ar costa nimic;
  • prev_hash: cineva a inserat, șters sau reordonat blocuri; fiecare bloc, luat separat, pare valid;
  • geneza: un lanț complet valid, dar care pornește din altă geneză, aparține altei rețele.

Ce lipsește încă față de un nod real: validarea tranzacțiilor (semnături, fonduri suficiente, fără dublă cheltuire), regulile de timestamp și dificultatea calculată din istoric, nu primită ca parametru. În proiectul din curs, aceste verificări se adaugă treptat; în interviu e bine să spui singur ce n-ai acoperit.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă înțelegi ce protejează fiecare regulă. Candidații uită de obicei verificarea dificultății, adică exact ce face rescrierea scumpă.

Eroarea, în practică:Lanț invalid după modificarea unui blocCâmpul hash inclus în propriul hash

27 Junior

Unde sunt bug-urile în codul de minare de mai jos?

PYTHON
import hashlib

class Block:
    def __init__(self, data, prev_hash):
        self.data = data
        self.prev_hash = prev_hash
        self.nonce = 0
        self.hash = self.compute_hash()

    def compute_hash(self):
        s = f"{self.data}{self.prev_hash}{self.nonce}"
        return hashlib.sha256(s.encode()).hexdigest()

    def mine(self, difficulty):
        while not self.hash.startswith("0" * difficulty):
            self.nonce += 1

Răspuns scurt: Bug-ul principal: mine schimbă nonce-ul, dar nu recalculează self.hash, deci bucla nu se termină niciodată. Al doilea: concatenarea fără separatori e ambiguă, iar câmpuri diferite pot produce același șir.

Bucla infinită. self.hash este calculat o dată, în constructor. În mine, condiția se uită la aceeași valoare la fiecare iterație, iar nonce crește degeaba. Corectura:

PYTHON
    def mine(self, difficulty):
        prefix = "0" * difficulty
        self.hash = self.compute_hash()
        while not self.hash.startswith(prefix):
            self.nonce += 1
            self.hash = self.compute_hash()

Concatenarea ambiguă. f"{data}{prev_hash}{nonce}" nu marchează unde se termină un câmp. Exemplu simplu: un bloc cu data="5" și nonce=12 produce același text ca unul cu data="51" și nonce=2, dacă prev_hash e gol. Două blocuri diferite ar avea același hash, ceea ce rupe ideea de amprentă unică. Soluția: o serializare cu structură, de exemplu json.dumps(..., sort_keys=True), sau câmpuri de lungime fixă, cum face Bitcoin.

Lipsuri de design, bune de menționat:

  • nu există timestamp, deci nimic nu ancorează blocul în timp;
  • data poate fi orice obiect, iar reprezentarea lui ca text depinde de tip (pentru un dict, de ordinea cheilor);
  • difficulty vine din afară, în loc să fie o regulă a lanțului.

Bug-ul cu hash-ul necalculat apare foarte des în proiectele de început, pentru că testul trece la difficulty=0, unde condiția e adevărată din prima.

Ce urmărește intervievatorul: Exercițiu tipic de code review. Primul bug îl găsesc aproape toți; al doilea separă candidații care înțeleg că hash-ul trebuie să fie al unei reprezentări neambigue.

Eroarea, în practică:Minarea nu găsește niciun nonce

28 Junior

Ce face un nod complet Bitcoin, pas cu pas, când primește un bloc nou de la un vecin?

Răspuns scurt: Verifică întâi antetul (Proof of Work, legătura cu un bloc cunoscut, timestamp, dificultatea corectă), apoi rădăcina Merkle și fiecare tranzacție față de setul UTXO. Dacă totul e valid, actualizează starea, alege lanțul cu cea mai multă muncă și retransmite blocul.

Un nod complet nu are încredere în nimeni. Validarea are un ordin de la ieftin la scump, ca să respingă rapid blocurile proaste:

  • antetul: hash-ul double SHA-256 este sub ținta indicată de bits, iar bits este exact dificultatea cerută de regulile de ajustare; prev_hash indică un bloc cunoscut; timestamp-ul e mai mare decât mediana ultimelor 11 blocuri și nu e prea departe în viitor;
  • structura: dimensiunea (weight) nu depășește limita; prima tranzacție, și numai ea, este coinbase; rădăcina Merkle calculată din tranzacții coincide cu cea din antet;
  • fiecare tranzacție: intrările se referă la UTXO-uri existente și necheltuite; nicio ieșire nu e cheltuită de două ori în același bloc; scripturile și semnăturile sunt valide; suma ieșirilor nu depășește suma intrărilor; locktime-urile sunt respectate;
  • coinbase: nu cere mai mult decât subvenția blocului plus comisioanele.

Dacă blocul prelungește lanțul activ, nodul actualizează setul UTXO și scoate din mempool tranzacțiile incluse. Dacă blocul creează o ramură cu mai multă muncă cumulată, nodul face o reorganizare: anulează blocurile vechi și aplică noua ramură.

Apoi anunță blocul vecinilor. În practică, cu compact blocks (BIP152), nodul primește doar identificatori scurți ai tranzacțiilor, pe care de obicei le are deja în mempool.

Esențial: un bloc invalid este respins indiferent câtă putere de calcul are minerul care l-a produs.

Ce urmărește intervievatorul: Se verifică dacă înțelegi rolul nodurilor complete în securitatea rețelei. Răspunsurile slabe se opresc la „verifică hash-ul”.

Eroarea, în practică:Nodul acceptă un lanț mai lung, dar invalid

29 Junior

Cum se propagă tranzacțiile și blocurile într-o rețea peer-to-peer ca Bitcoin? Ce sunt mesajele inv și getdata și de ce nu trimiți direct datele?

Răspuns scurt: Prin gossip: fiecare nod anunță vecinilor ce are nou cu un mesaj inv care conține doar identificatori. Vecinii cer cu getdata numai ce nu au deja. Așa se evită trimiterea aceleiași tranzacții de zeci de ori fiecărui nod.

Într-o rețea P2P nu există server central. Fiecare nod are câțiva vecini (în Bitcoin Core, implicit 8 conexiuni de ieșire, plus cele de intrare acceptate) și informația se răspândește ca o bârfă: fiecare o spune vecinilor, care o spun vecinilor lor.

Dacă fiecare nod ar trimite direct tranzacția completă tuturor vecinilor, fiecare nod ar primi aceeași tranzacție de la mai mulți vecini, irosind lățime de bandă. De aceea protocolul are doi pași:

  • inv (inventory): „am tranzacțiile sau blocurile cu aceste hash-uri”; un hash are 32 de bytes, mult mai puțin decât o tranzacție;
  • getdata: „trimite-mi-le pe acestea”, doar pentru cele lipsă;
  • apoi vin datele propriu-zise, în mesaje tx sau block.
Nod A                    Nod B
  | --- inv [txid] --->  |
  | <-- getdata [txid] - |   (B nu o are)
  | --- tx [...]  ---->  |

Detalii utile la interviu:

  • nodurile validează o tranzacție înainte s-o retransmită, deci gunoiul nu se propagă;
  • Bitcoin Core adaugă întârzieri aleatoare la anunțuri, ca să fie mai greu de aflat ce nod a emis primul o tranzacție;
  • pentru blocuri, compact blocks reduc mult datele, iar antetele pot fi trimise direct cu mesajul headers;
  • Erlay (BIP330) propune reconcilierea seturilor de tranzacții pentru și mai puțin trafic.

Ce urmărește intervievatorul: Verifică înțelegerea mecanicii rețelei din materia cursului. Candidații spun adesea doar „se trimite la toată lumea”, fără să explice cum se evită duplicarea.

Eroarea, în practică:Propagarea în rețea nu se mai oprește

30 Mid

Cum verifică un nod ușor (SPV) că a primit o plată fără să descarce tot blockchain-ul? Ce ipoteze de încredere face și ce limitări are?

Răspuns scurt: Descarcă doar antetele blocurilor (80 de bytes fiecare), verifică Proof of Work și legăturile, apoi cere o dovadă Merkle că tranzacția e inclusă într-un bloc. Presupune că lanțul cu cea mai multă muncă conține doar blocuri valide, pe care nu le poate verifica singur.

SPV (Simplified Payment Verification) este descris chiar în whitepaper-ul Bitcoin, secțiunea 8. Pașii:

  • nodul descarcă toate antetele de bloc. Toate antetele de la geneză până azi ocupă doar zeci de MB;
  • verifică pentru fiecare antet că hash-ul respectă ținta și că prev_hash leagă antetele, deci poate determina lanțul cu cea mai multă muncă;
  • pentru o tranzacție care îl interesează, primește de la un nod complet tranzacția și o dovadă Merkle până la rădăcina din antet;
  • numără câte blocuri au fost construite peste el (confirmările).

Ipoteza de încredere: majoritatea puterii de calcul este onestă. Nodul SPV nu verifică dacă tranzacțiile sunt valide; dacă minerii ar produce un bloc invalid, un nod SPV l-ar accepta, pe când un nod complet l-ar respinge.

Limitări:

  • dovezile de incluziune nu dovedesc absența: nodul nu poate ști sigur că nu i s-a ascuns o tranzacție;
  • confidențialitate: vechile filtre Bloom (BIP37) dezvăluiau adresele portofelului nodului complet interogat. Noile filtre compacte (BIP157/158) inversează direcția: nodul complet publică un filtru per bloc, iar clientul îl verifică local;
  • eclipsare: dacă toți vecinii sunt ai atacatorului, i se poate arăta un lanț fals mai scurt;
  • depinde de noduri complete care să-i servească date.

Multe wallet-uri mobile folosesc de fapt un server propriu (Electrum, API-uri), ceea ce e o încredere și mai mare decât SPV.

Ce urmărește intervievatorul: Întrebarea leagă arborii Merkle de arhitectura rețelei. Se verifică dacă știi exact ce verifică și ce nu verifică un client ușor.

31 Mid

Ce sunt blocurile orfane (stale) și de ce un timp de bloc mai scurt crește numărul lor? Ce efect au asupra securității?

Răspuns scurt: Un bloc stale este un bloc valid care pierde cursa în fața altui bloc de la aceeași înălțime. Cu cât timpul de bloc e mai scurt față de timpul de propagare, cu atât astfel de ciocniri sunt mai dese, iar munca se irosește.

Termenul corect este stale block: bloc valid, dar care nu face parte din lanțul principal. „Orfan” se folosea istoric și pentru blocuri al căror părinte nu era încă cunoscut, de unde confuzia.

Cum apare: minerul A găsește un bloc și îl propagă. Până când blocul ajunge la toți, minerul B, care încă nu l-a văzut, găsește și el un bloc la aceeași înălțime. Rețeaua se împarte temporar; la următorul bloc, o ramură devine mai lungă și cealaltă e abandonată.

De ce contează raportul dintre timpul de propagare și timpul de bloc: dacă propagarea durează câteva secunde, iar un bloc apare la 10 minute, coliziunile sunt rare. Dacă ai bloc la câteva secunde, o parte importantă din blocuri se ciocnesc.

Efecte:

  • securitate redusă: munca minerilor onești de pe ramurile pierdute nu contribuie la lanțul principal, dar un atacator care minează privat nu pierde nimic. Pragul real pentru atac scade sub 50%;
  • avantaj pentru minerii mari: un pool mare găsește mai des blocuri consecutive și nu concurează cu el însuși, ceea ce încurajează centralizarea;
  • confirmări mai puțin sigure individual.

Soluții: propagare mai rapidă (compact blocks, rețele dedicate de relay), protocoale care recompensează parțial blocurile pierdute (Ethereum PoW avea „uncles” prin GHOST) sau consens cu lideri programați, ca în Proof of Stake, unde fiecare slot are un propunător desemnat.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce timpul de bloc nu se poate reduce oricât. Candidații cred adesea că 10 minute e o alegere arbitrară, care poate fi scurtată fără costuri.

32 Mid

Cum își găsește un nod Bitcoin nou vecinii și ce este un atac de eclipsare (eclipse attack)?

Răspuns scurt: La prima pornire folosește seed-uri DNS și o listă de adrese scrisă în cod, apoi află alte adrese de la vecini prin mesaje addr. Într-un atac de eclipsare, atacatorul controlează toate conexiunile unui nod și îi arată doar ce vrea el.

Descoperirea vecinilor în Bitcoin Core:

  • seed-uri DNS: nume de domeniu întreținute de dezvoltatori, care întorc adrese IP de noduri active;
  • fixed seeds: o listă de adrese inclusă în cod, folosită dacă DNS-ul nu răspunde;
  • mesaje addr / addrv2: vecinii își trimit adrese cunoscute, iar nodul le păstrează într-o bază locală (peers.dat), împărțită în „găleți” după rețele, ca la repornire să nu depindă de seed-uri.

Eclipse attack: atacatorul umple tabela de adrese a victimei cu IP-uri controlate de el și așteaptă o repornire, ca toate conexiunile să meargă la el. Victima vede atunci doar blocurile și tranzacțiile filtrate de atacator. Consecințe:

  • poate fi păcălită cu o dublă cheltuire: i se arată o tranzacție confirmată pe o ramură privată;
  • puterea de calcul a unui miner eclipsat e irosită pe o ramură izolată;
  • tranzacțiile victimei pot fi cenzurate.

Apărări introduse după studii academice despre acest atac:

  • adresele sunt grupate după prefixul rețelei (și după sistemul autonom, cu asmap), iar un nod nu se conectează la multe adrese din același grup;
  • anchor connections: la repornire, nodul se reconectează la câțiva vecini de încredere de dinainte;
  • conexiuni de ieșire suplimentare, doar pentru blocuri;
  • rularea peste mai multe rețele (IPv4, IPv6, Tor, I2P) face mai greu de controlat toate căile.

Ce urmărește intervievatorul: Se verifică dacă vezi rețeaua ca suprafață de atac, nu doar consensul. Mulți candidați nu știu că securitatea unui nod depinde și de cu cine e conectat.

33 Mid

Ce reguli are timestamp-ul unui bloc Bitcoin și de ce nu poate fi pur și simplu „ora exactă”? Ce s-ar întâmpla fără aceste reguli?

Răspuns scurt: Timestamp-ul trebuie să fie peste mediana ultimelor 11 blocuri și cel mult cu 2 ore în viitor față de timpul ajustat al rețelei. Nodurile nu au un ceas comun, iar fără reguli minerii ar manipula ajustarea dificultății.

Într-o rețea descentralizată nu există un ceas oficial. Fiecare nod are ceasul lui, iar un miner poate scrie ce vrea în câmpul time. Regulile limitează cât de mult poate minți:

  • Median Time Past (MTP): timestamp-ul trebuie să fie strict mai mare decât mediana timestamp-urilor ultimelor 11 blocuri. Mediana nu poate fi împinsă de un singur bloc cu o valoare extremă;
  • limita din viitor: un nod respinge temporar blocul dacă timestamp-ul e cu mai mult de 2 ore după timpul lui ajustat. Blocul poate fi acceptat mai târziu, când timpul ajunge acolo.

Consecința neintuitivă: timestamp-urile nu sunt strict crescătoare. Un bloc poate avea o oră mai mică decât blocul anterior.

De ce contează:

  • ajustarea dificultății se calculează din timestamp-uri. Dacă minerii ar putea scrie orice dată, ar putea face să pară că blocurile au venit încet și ar scădea dificultatea. Un exemplu real este atacul de tip time warp, care exploata un detaliu al ajustării la 2016 blocuri și a fost exploatat pe unele rețele alternative și de test; propunerea Consensus Cleanup (BIP54) include o corecție pentru el;
  • timelock-urile relative și absolute (BIP65, BIP68, BIP113) folosesc MTP în loc de timestamp-ul blocului, tocmai ca minerii să nu poată debloca fonduri mai devreme.

Pentru aplicații: nu folosi timestamp-ul blocului ca sursă precisă de timp; e o aproximare cu toleranță de ordinul orelor.

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi că și cel mai banal câmp are implicații de consens. Greșeala tipică este presupunerea că blocurile au timestamp-uri ordonate.

Bitcoin: UTXO, tranzacții și mempool

34 Junior

De ce Bitcoin reprezintă sumele în satoshi, ca numere întregi, și nu în BTC cu zecimale? Ce afișează codul?

PYTHON
print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(10_000_000 + 20_000_000 == 30_000_000)

Răspuns scurt: Afișează 0.30000000000000004, False și True. Numerele float nu pot reprezenta exact majoritatea fracțiilor zecimale, deci sumele ar avea erori de rotunjire. Un satoshi e a suta milioana parte dintr-un bitcoin, iar toate calculele se fac cu întregi.

float în Python este un număr binar în virgulă mobilă (IEEE 754, 64 de biți). Valori precum 0.1 sau 0.2 au o infinitate de cifre în baza 2, așa că sunt stocate aproximativ. Suma aproximărilor nu e exact 0.3.

Într-un sistem de plăți, astfel de erori sunt inacceptabile:

  • dacă suma intrărilor minus suma ieșirilor dă 0.00000000000000004 în loc de 0, comisionul e greșit;
  • două noduri care calculează pe platforme diferite ar putea ajunge la rezultate diferite și ar respinge blocuri valide, adică o rupere de consens;
  • comparațiile de egalitate devin nesigure.

Bitcoin stochează toate valorile ca întregi pe 64 de biți, în satoshi: 1 BTC = 100_000_000 sat. Valoarea cu zecimale apare doar la afișare.

PYTHON
SAT_PER_BTC = 100_000_000

def to_sat(btc: str) -> int:
    from decimal import Decimal
    return int(Decimal(btc) * SAT_PER_BTC)

print(to_sat("0.1") + to_sat("0.2") == to_sat("0.3"))   # True

Conversia folosește Decimal dintr-un șir, nu dintr-un float, ca să nu introducă eroarea chiar la intrare.

Ethereum face la fel: soldurile sunt întregi în wei (10^18 wei într-un ether), iar tokenurile ERC-20 au un câmp decimals folosit doar pentru afișare. EVM nici nu are tip float.

Ce urmărește intervievatorul: Este o întrebare simplă care verifică reflexele de programator în sisteme financiare. Greșeala tipică este să crezi că rotunjirea la 8 zecimale rezolvă problema.

Eroarea, în practică:0.30000000000000004 la sume cu floatunsupported operand for *: 'Decimal' and 'float'

35 Junior

Ana are două UTXO-uri, de 50.000 și 30.000 de satoshi. Vrea să-i trimită lui Dan 60.000 și să plătească un comision de 1.000. Cum arată tranzacția?

Răspuns scurt: Are două intrări (ambele UTXO-uri, total 80.000) și două ieșiri: 60.000 către Dan și 19.000 rest către o adresă a Anei. Comisionul nu apare explicit: este diferența de 1.000 dintre intrări și ieșiri.

În modelul UTXO nu există un „sold” care scade. Există monede individuale (ieșiri necheltuite), care se consumă întotdeauna în întregime, ca o bancnotă.

Intrări                          Ieșiri
UTXO A (Ana)   50.000 sat   →    Dan            60.000 sat
UTXO B (Ana)   30.000 sat   →    Ana (rest)     19.000 sat
total          80.000 sat        total          79.000 sat
                                 comision = 80.000 − 79.000 = 1.000

Pași:

  • niciun UTXO singur nu acoperă 61.000, deci wallet-ul le folosește pe amândouă;
  • fiecare intrare se referă la un UTXO prin (txid, index) și conține o semnătură care dovedește dreptul de a-l cheltui;
  • ieșirea de rest merge de obicei la o adresă nouă a Anei (change address), generată de wallet, pentru confidențialitate;
  • comisionul nu e un câmp; minerul îl încasează implicit, adăugându-l la tranzacția coinbase.

După confirmare, UTXO A și B dispar din setul UTXO, iar în locul lor apar două noi: unul al lui Dan și unul al Anei.

Observații pe care le apreciază intervievatorii:

  • un observator al lanțului poate deduce că ambele intrări aparțin aceleiași persoane (euristica intrărilor comune), un dezavantaj de confidențialitate;
  • comisionul depinde de dimensiunea tranzacției în vbytes, nu de suma trimisă; două intrări fac tranzacția mai mare decât una.

Ce urmărește intervievatorul: Se verifică dacă ai înțeles concret modelul UTXO, nu doar definiția lui. Candidații uită frecvent ieșirea de rest sau cred că comisionul e o ieșire separată.

Eroarea, în practică:Restul uitat: diferența devine comision

36 Junior

Un programator construiește manual o tranzacție cu o intrare de 1.000.000 de satoshi și o singură ieșire de 100.000 către un prieten. Tranzacția se confirmă rapid. Ce s-a întâmplat?

Răspuns scurt: A uitat ieșirea de rest. Diferența de 900.000 de satoshi a fost considerată comision și a intrat la minerul blocului. Tranzacția e validă și ireversibilă.

Regula Bitcoin pentru comision este simplă: comision = suma intrărilor − suma ieșirilor. Protocolul nu știe ce intenționai. Dacă ieșirile sunt mai mici, tot restul merge la miner.

PYTHON
def fee(inputs: list[int], outputs: list[int]) -> int:
    f = sum(inputs) - sum(outputs)
    if f < 0:
        raise ValueError("ieșirile depășesc intrările: tranzacție invalidă")
    return f

print(fee([1_000_000], [100_000]))   # 900000

Tranzacția s-a confirmat rapid tocmai pentru că avea un comision uriaș, deci era prima în ordinea preferințelor minerilor.

Ce se mai poate face: practic nimic. Nu există un mecanism de anulare. Unele pool-uri de minare au returnat voluntar comisioane evident greșite, dar asta ține de bunăvoința lor.

Cum previi:

  • folosești o bibliotecă sau un wallet care adaugă automat ieșirea de rest;
  • pui o verificare de siguranță: refuzi semnarea dacă comisionul depășește un prag sau un procent din valoare. Bitcoin Core are opțiunea maxfeerate la sendrawtransaction, care respinge implicit comisioanele prea mari;
  • calculezi comisionul din rata dorită (sat/vB) și dimensiunea estimată, apoi rest = intrări − plată − comision;
  • testezi pe testnet sau regtest înainte de mainnet.

E o întrebare bună pentru a arăta că înțelegi diferența dintre ce e valid și ce e intenționat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi că protocolul nu protejează utilizatorul de propriile greșeli. Răspunsul bun include și măsuri concrete de prevenție în cod.

Eroarea, în practică:Restul uitat: diferența devine comision

37 Junior

Ce este tranzacția coinbase, prin ce diferă de o tranzacție obișnuită și de ce monedele din ea nu pot fi cheltuite imediat?

Răspuns scurt: Este prima tranzacție din fiecare bloc, creată de miner, fără intrări reale, prin care ia subvenția plus comisioanele. Ieșirile ei pot fi cheltuite abia după 100 de blocuri, pentru că o reorganizare ar putea face blocul să dispară.

Tranzacția coinbase este singura modalitate prin care apar bitcoini noi. Diferențe față de o tranzacție normală:

  • are o singură intrare, care nu indică un UTXO real: txid e format din zerouri, iar indexul este 0xffffffff;
  • câmpul scriptSig al intrării poate conține date arbitrare (până la 100 de bytes). Satoshi a pus în blocul geneză titlul unui ziar din 3 ianuarie 2009; minerii pun aici identificatorul pool-ului și extraNonce;
  • din BIP34, trebuie să înceapă cu înălțimea blocului, ca două tranzacții coinbase să nu fie identice;
  • valoarea ieșirilor nu poate depăși subvenție + suma comisioanelor din bloc. Minerul poate lua mai puțin (monedele nerevendicate se pierd definitiv), dar nu mai mult;
  • după SegWit, conține și angajamentul pentru datele witness (rădăcina Merkle a wtxid-urilor).

Maturitatea de 100 de blocuri: dacă blocul ar fi abandonat într-o reorganizare, tranzacția coinbase ar dispărea complet, nu doar ar redeveni neconfirmată, cum se întâmplă cu tranzacțiile obișnuite, care pot fi reincluse în alt bloc. Toate tranzacțiile care ar fi cheltuit acele monede ar deveni invalide definitiv. Regula de 100 de blocuri face un astfel de scenariu practic imposibil.

În proiectul din curs, unde construiești recompensa minerului, merită să implementezi aceeași regulă: UTXO-urile coinbase marcate cu înălțimea și verificate la cheltuire.

Ce urmărește intervievatorul: Se verifică înțelegerea emiterii monetare și a interacțiunii cu reorganizările. Puțini candidați pot explica motivul maturității de 100 de blocuri.

38 Junior

De ce Bitcoin Script nu este Turing-complet? Este o limitare sau o alegere de design?

Răspuns scurt: Este o alegere: Script nu are bucle și nici salturi înapoi, deci fiecare script se termină într-un timp previzibil. Nodurile pot valida orice tranzacție fără risc de bucle infinite și fără un mecanism de tip gas.

Bitcoin Script este un limbaj pe stivă, în stilul Forth: instrucțiuni care pun date pe stivă sau operează pe ele (OP_DUP, OP_HASH160, OP_CHECKSIG). Are condiții (OP_IF), dar nu are bucle și nu poate sări înapoi.

Motivele alegerii:

  • terminare garantată: un program fără bucle se execută în cel mult atâția pași câte instrucțiuni are. Nodurile pot estima costul validării înainte de execuție;
  • fără gas: Ethereum are nevoie de gas tocmai pentru că EVM poate rula bucle; fără o limită plătită, un contract ar putea bloca toate nodurile. Bitcoin evită complet problema;
  • suprafață de atac redusă: regulile simple sunt mai ușor de auditat. Satoshi a dezactivat devreme mai multe opcode-uri (de exemplu OP_CAT, OP_MUL) după ce s-au descoperit bug-uri;
  • validare fără stare globală: un script vede doar tranzacția și ieșirea cheltuită, nu restul lanțului. Validarea se poate face în paralel și nu depinde de ordinea tranzacțiilor din bloc.

Ce se poate face totuși: multisig, timelock-uri (OP_CHECKLOCKTIMEVERIFY, OP_CHECKSEQUENCEVERIFY), hash locks, canale Lightning și, cu Taproot, arbori de condiții.

Compromisul: aplicații complexe (DeFi, tokeni cu logică) nu se pot scrie direct pe Bitcoin. Există dezbateri continue despre opcode-uri noi (OP_CAT, OP_CHECKTEMPLATEVERIFY), care ar adăuga expresivitate fără bucle.

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul dintre expresivitate și siguranță. Răspunsul slab este „Bitcoin e vechi și limitat”, fără legătură cu validarea.

39 Junior

Ce este „dust” în Bitcoin și de ce un nod refuză să retransmită o tranzacție care creează o ieșire de câțiva satoshi?

Răspuns scurt: Dust este o ieșire atât de mică încât comisionul necesar pentru a o cheltui ar fi mai mare decât valoarea ei. Nodurile Bitcoin Core consideră astfel de tranzacții nestandard și nu le retransmit, ca să nu umfle setul UTXO cu monede practic inutilizabile.

Fiecare UTXO trebuie păstrat de toate nodurile complete până este cheltuit. O ieșire de 10 satoshi pe care nimeni nu o va cheltui vreodată, pentru că ar costa mai mult în comision, ocupă spațiu pe toate nodurile pentru totdeauna.

Bitcoin Core are o regulă de politică (nu de consens): o ieșire sub pragul de dust face tranzacția nestandard. Pragul se calculează din dimensiunea ieșirii și a intrării necesare pentru a o cheltui, cu o rată de referință dustrelayfee. Pentru o ieșire P2PKH obișnuită valoarea folosită uzual este 546 de satoshi, iar pentru tipurile SegWit e mai mică, pentru că sunt mai ieftine de cheltuit.

Diferența dintre politică și consens e importantă la interviu:

  • regulile de consens decid dacă un bloc e valid; încălcarea lor înseamnă bloc respins;
  • regulile de politică decid ce tranzacții retransmite și păstrează în mempool un nod. Un miner poate include totuși o tranzacție nestandard dacă o primește direct, iar blocul rămâne valid.

Dusting attack: cineva trimite sume mici către multe adrese și urmărește apoi dacă proprietarii le cheltuiesc împreună cu alte monede, ca să lege adresele între ele. Wallet-urile bune permit marcarea acestor UTXO-uri ca „nu cheltui” (coin control).

Pentru wallet-ul tău: nu crea ieșiri de rest foarte mici; dacă restul ar fi dust, adaugă-l la comision.

Ce urmărește intervievatorul: Se verifică dacă știi diferența dintre regulile de consens și cele de politică ale nodurilor. Mulți candidați nu știu că un nod poate refuza o tranzacție validă.

40 Mid

Scrie funcția apply_tx(utxos, tx, txid) care aplică o tranzacție pe setul UTXO și întoarce comisionul. Ce verificări sunt obligatorii?

Răspuns scurt: Verifici că fiecare intrare există în set, că nu apare de două ori în aceeași tranzacție și că ieșirile nu depășesc intrările. Doar după toate verificările ștergi intrările și adaugi ieșirile noi cu cheia (txid, index).

PYTHON
def apply_tx(utxos: dict, tx: dict, txid: str) -> int:
    inputs = tx["inputs"]                 # listă de tupluri (txid, index)
    if len(set(inputs)) != len(inputs):
        raise ValueError("aceeași ieșire e cheltuită de două ori în tranzacție")
    total_in = 0
    for ref in inputs:
        if ref not in utxos:
            raise ValueError(f"UTXO inexistent sau deja cheltuit: {ref}")
        total_in += utxos[ref]["amount"]
    outputs = tx["outputs"]
    if any(o["amount"] <= 0 for o in outputs):
        raise ValueError("sume invalide")
    total_out = sum(o["amount"] for o in outputs)
    if total_out > total_in:
        raise ValueError("ieșirile depășesc intrările")
    for ref in inputs:
        del utxos[ref]
    for i, out in enumerate(outputs):
        utxos[(txid, i)] = out
    return total_in - total_out

Puncte importante:

  • validezi complet înainte să modifici: dacă ștergi o intrare și apoi descoperi o eroare, setul rămâne corupt. Alternativ, lucrezi pe o copie și o înlocuiești la final;
  • dublura în aceeași tranzacție: fără verificarea cu set, o intrare de 50 apărută de două ori ar număra 100. Un bug similar (CVE-2018-17144) a existat chiar în Bitcoin Core și permitea, în anumite condiții, crearea de monede;
  • sume negative sau zero: o ieșire negativă ar putea „crea” bani în sumă;
  • lipsește încă verificarea semnăturilor: fiecare intrare trebuie să dovedească dreptul asupra UTXO-ului referit;
  • la aplicarea unui bloc, verifici și conflictele dintre tranzacții diferite din același bloc, iar pentru reorganizări păstrezi datele necesare ca să poți anula tranzacția (undo data).

Ce urmărește intervievatorul: Este o întrebare de cod centrală pentru proiectul din curs. Separă candidații care se gândesc la atomicitate și la cazurile limită de cei care scriu doar fluxul fericit.

Eroarea, în practică:Dublă cheltuire acceptată (double spend)

41 Mid

Un miner are în mempool tranzacții cu comisioane și dimensiuni diferite. Scrie o funcție care alege tranzacțiile pentru un bloc cu limită de dimensiune. De ce se sortează după rata comisionului și nu după comisionul total?

Răspuns scurt: Sortezi descrescător după fee / vsize (satoshi pe vbyte) și adaugi cât încape. Spațiul din bloc e resursa limitată, deci contează câți bani aduce fiecare vbyte, nu suma absolută a unei tranzacții.

PYTHON
def select_txs(mempool: list[dict], max_vsize: int) -> list[dict]:
    chosen, used = [], 0
    by_rate = sorted(mempool, key=lambda t: t["fee"] / t["vsize"], reverse=True)
    for tx in by_rate:
        if used + tx["vsize"] <= max_vsize:
            chosen.append(tx)
            used += tx["vsize"]
    return chosen

De ce rata: o tranzacție cu comision 10.000 sat și 5.000 vB plătește 2 sat/vB. Zece tranzacții de 200 vB cu 1.000 sat fiecare plătesc tot 10.000 sat în total, dar ocupă doar 2.000 vB și lasă loc pentru altele. Minerul maximizează venitul pe spațiul limitat, deci e o problemă de tip rucsac, iar sortarea greedy după rată e o aproximare bună.

Ce lipsește din varianta simplă și ar trebui spus la interviu:

  • dependențele: o tranzacție care cheltuie ieșirea unei alte tranzacții neconfirmate poate fi inclusă doar după părinte. Bitcoin Core evaluează pachete după ancestor feerate (rata medie a tranzacției împreună cu strămoșii neconfirmați); pe asta se bazează CPFP;
  • spațiul real se măsoară în weight units, cu limita de 4 milioane WU per bloc; vsize = weight / 4;
  • se rezervă loc pentru tranzacția coinbase;
  • la final, greedy-ul poate lăsa spațiu nefolosit; se mai încearcă tranzacții mici care încap.

Din perspectiva utilizatorului: comisionul se setează în sat/vB, iar estimarea se face din starea mempool-ului, nu din valoarea trimisă.

Ce urmărește intervievatorul: Verifică dacă înțelegi economia spațiului de bloc și știi să scrii o soluție simplă cu limitele ei. Candidații slabi sortează după comisionul total.

Eroarea, în practică:'<' not supported between 'dict' and 'dict'

42 Mid

O tranzacție Bitcoin rămâne neconfirmată pentru că a avut un comision prea mic. Explică RBF și CPFP: cum funcționează fiecare și când îl folosești pe care?

Răspuns scurt: RBF (Replace-By-Fee) înlocuiește tranzacția cu o versiune nouă care cheltuie aceleași intrări cu un comision mai mare. CPFP (Child-Pays-For-Parent) creează o tranzacție-copil care cheltuie o ieșire a celei blocate și plătește un comision suficient pentru amândouă.

RBF (BIP125): expeditorul semnează din nou tranzacția, cu aceleași intrări, dar ieșiri ajustate (de obicei restul scade), deci comision mai mare. Nodurile acceptă înlocuirea dacă noua versiune plătește un comision total mai mare și o rată mai bună. Istoric, tranzacția trebuia să semnaleze opțiunea RBF prin câmpul nSequence; începând cu Bitcoin Core 28, full-RBF este comportamentul implicit, deci nodurile acceptă înlocuirea și fără semnalizare.

  • îl poate face doar expeditorul, pentru că doar el poate semna intrările;
  • consumă puțin spațiu suplimentar: se publică doar tranzacția nouă.

CPFP: minerii evaluează pachete. Dacă părintele are 1 sat/vB și copilul plătește destul de mult încât rata medie a pachetului să fie atractivă, minerul le include pe amândouă, pentru că copilul nu poate intra fără părinte.

  • îl poate face oricine controlează o ieșire a tranzacției blocate: destinatarul (pentru ieșirea primită) sau expeditorul (pentru rest);
  • costă mai mult: plătești și pentru tranzacția copil.

Când pe care:

  • expeditor cu wallet care suportă RBF: RBF, e mai ieftin;
  • destinatar care vrea banii mai repede: CPFP;
  • tranzacții pre-semnate (de exemplu în Lightning) care nu pot fi resemnate: CPFP, cu ieșiri speciale pentru asta (anchor outputs).

Atenție: o tranzacție înlocuită prin RBF are alt txid. Un comerciant care acceptă plăți cu zero confirmări trebuie să știe că plata poate fi înlocuită cu una către altă adresă.

Ce urmărește intervievatorul: Este o problemă reală din suportul pentru utilizatori. Verifică dacă știi cine poate aplica fiecare metodă și ce implicații are înlocuirea pentru comercianți.

43 Mid

Explică execuția pe stivă a unei cheltuiri P2PKH: scriptSig <sig> <pubKey> și scriptPubKey OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG.

Răspuns scurt: Se pun pe stivă semnătura și cheia publică, se duplică cheia, se calculează HASH160 al ei și se compară cu hash-ul din ieșire, apoi OP_CHECKSIG verifică semnătura cu cheia. Scriptul reușește dacă la final pe stivă rămâne „adevărat”.

Ieșirea (scriptPubKey) spune: „poate cheltui cine prezintă o cheie publică al cărei hash este X și o semnătură validă cu ea”. Intrarea (scriptSig) oferă datele. Nodul execută întâi scriptSig, apoi scriptPubKey pe aceeași stivă.

Pas                 Stiva (vârful la dreapta)
<sig>               sig
<pubKey>            sig pubKey
OP_DUP              sig pubKey pubKey
OP_HASH160          sig pubKey hash(pubKey)
<pubKeyHash>        sig pubKey hash(pubKey) pubKeyHash
OP_EQUALVERIFY      sig pubKey          (oprește dacă hash-urile diferă)
OP_CHECKSIG         true                (dacă semnătura e validă)

Ce verifică fiecare parte:

  • OP_DUP + OP_HASH160 + OP_EQUALVERIFY: cheia publică prezentată corespunde adresei. Fără OP_DUP, cheia ar fi consumată de hash și n-ar mai rămâne pentru verificarea semnăturii;
  • OP_CHECKSIG: semnătura e validă pentru cheie și pentru hash-ul tranzacției care cheltuie (sighash). Acesta e pasul care leagă semnătura de această tranzacție anume, ca să nu poată fi refolosită.

Istoric, Bitcoin executa cele două scripturi concatenate. Un bug din 2010 permitea un scriptSig cu OP_RETURN care cheltuia orice ieșire; de atunci, scripturile se execută separat, iar scriptSig poate conține doar operații care pun date pe stivă (regulă de politică).

În P2WPKH (SegWit), logica e aceeași, dar semnătura și cheia stau în witness, iar scriptPubKey e doar 0 <pubKeyHash>, cu șablonul implicit în regulile de consens.

Ce urmărește intervievatorul: Se verifică dacă poți urmări mental o execuție pe stivă, exercițiu din lecția despre Bitcoin Script. Candidații uită de ce e nevoie de OP_DUP.

44 Mid

Ce probleme a rezolvat SegWit (BIP141) și cum se calculează dimensiunea unei tranzacții în weight units și vbytes?

Răspuns scurt: SegWit a mutat semnăturile în structura witness, separată de txid, eliminând maleabilitatea txid-ului. A introdus weight: datele obișnuite costă 4 WU per byte, iar datele witness 1 WU per byte, cu limita de 4 milioane WU per bloc. vbytes = weight / 4.

SegWit a fost activat în august 2017, ca soft fork. Probleme rezolvate:

  • maleabilitatea txid-ului: txid-ul se calculează fără witness, deci modificarea semnăturii nu mai schimbă identificatorul. Asta a permis lanțuri de tranzacții nesemnate încă, condiție pentru Lightning;
  • capacitate: datele witness sunt reduse la un sfert la calculul limitei, deci un bloc poate conține mai multe tranzacții, fără să crească limita veche de 1 MB pentru nodurile vechi;
  • hash-ul de semnătură pătratic: vechiul algoritm sighash refăcea hash-ul întregii tranzacții pentru fiecare intrare; BIP143 îl face liniar și include valoarea intrării, ceea ce ajută și wallet-urile hardware;
  • versionarea scripturilor: ieșirile încep cu un număr de versiune; Taproot este witness versiunea 1.

Calculul:

PYTHON
def weight(base_size: int, total_size: int) -> int:
    # base_size: tranzacția serializată fără witness
    # total_size: cu witness
    return base_size * 3 + total_size

def vsize(base_size: int, total_size: int) -> int:
    return (weight(base_size, total_size) + 3) // 4   # rotunjire în sus

Echivalent: fiecare byte non-witness costă 4 WU, fiecare byte witness 1 WU.

De ce a fost soft fork: nodurile vechi văd ieșirile SegWit ca „oricine poate cheltui” și nu primesc datele witness, dar blocurile rămân valide pentru ele. Nodurile actualizate aplică regulile noi, mai stricte.

Comisionul se calculează pe vbytes, deci adresele bc1q și bc1p sunt mai ieftine de cheltuit decât cele vechi care încep cu 1.

Ce urmărește intervievatorul: Verifică cunoașterea unei schimbări majore a protocolului și înțelegerea mecanismului, nu doar a numelui. Greșeala tipică: „SegWit a mărit blocul la 4 MB”.

45 Senior

Cum ai proiecta algoritmul de selecție a monedelor (coin selection) pentru un wallet Bitcoin? Ce compromisuri există?

Răspuns scurt: Alegi ce UTXO-uri folosești pentru o plată, echilibrând comisionul de acum, comisioanele viitoare, confidențialitatea și evitarea restului. Bitcoin Core rulează mai mulți algoritmi (Branch and Bound, Knapsack, CoinGrinder, Single Random Draw) și alege rezultatul cu cel mai mic cost estimat.

Problema: ai un set de UTXO-uri de valori diferite și trebuie să acoperi plată + comision. Fiecare intrare adaugă vbytes, deci comision, iar o ieșire de rest adaugă și ea cost acum și o intrare de cheltuit mai târziu.

Compromisuri principale:

  • comision acum vs mai târziu: dacă folosești multe UTXO-uri mici când comisioanele sunt mici, consolidezi și economisești pe viitor. Când comisioanele sunt mari, folosești cât mai puține intrări;
  • fără rest: dacă găsești o combinație care acoperă exact plata (cu o toleranță cât costul unui rest), eviți ieșirea de rest. Asta face Branch and Bound, o căutare în adâncime cu tăieri;
  • confidențialitate: combinarea UTXO-urilor din surse diferite le leagă între ele; restul cu tip de adresă diferit de plată arată care ieșire e restul. Selecția aleatoare (Single Random Draw) reduce tiparele previzibile;
  • dust: nu crea rest mai mic decât pragul; adaugă-l la comision;
  • UTXO-uri neconfirmate: folosirea lor e riscantă (pot fi înlocuite), deci au prioritate mică.

Bitcoin Core rulează în paralel mai mulți algoritmi și alege soluția cu metrica de risipă (waste) cea mai mică. Metrica include costul de a crea și de a cheltui ulterior restul, plus diferența dintre rata de acum și o rată pe termen lung.

Pentru un serviciu cu volum mare (exchange), apar și strategii operaționale: consolidarea periodică în perioade cu comision mic, plăți în lot (o tranzacție cu multe ieșiri) și gestionarea separată a portofelelor calde și reci.

Ce urmărește intervievatorul: Întrebarea e pentru roluri care construiesc wallet-uri sau infrastructură de plăți. Se verifică gândirea în compromisuri și cunoașterea algoritmilor reali, nu un singur răspuns corect.

Proof of Work și minare

46 Junior

Scrie o funcție de minare care găsește un nonce astfel încât hash-ul să înceapă cu k zerouri hexazecimale. Cât crește timpul mediu când k crește cu 1?

Răspuns scurt: Iterezi nonce-ul de la 0, calculezi hash-ul și te oprești când începe cu "0" * k. Fiecare cifră hex are 16 valori, deci un zero în plus înmulțește cu 16 numărul mediu de încercări.

PYTHON
import hashlib, time

def mine(header: str, k: int) -> tuple[int, str]:
    prefix = "0" * k
    nonce = 0
    while True:
        h = hashlib.sha256(f"{header}|{nonce}".encode()).hexdigest()
        if h.startswith(prefix):
            return nonce, h
        nonce += 1

for k in range(1, 6):
    t = time.perf_counter()
    nonce, h = mine("bloc-de-test", k)
    print(k, nonce, round(time.perf_counter() - t, 3))

Probabilitatea ca o cifră hex aleatoare să fie 0 este 1/16. Pentru k cifre de 0 la început, probabilitatea este 1/16^k, deci numărul mediu de încercări este 16^k. De la k = 4 la k = 5, munca medie crește de 16 ori. Valorile reale variază mult de la un bloc la altul: e un proces aleator, cu distribuție geometrică.

Ce ilustrează exercițiul:

  • asimetria: găsirea nonce-ului cere multe încercări, dar verificarea cere un singur hash;
  • lipsa scurtăturilor: efectul de avalanșă face ca singura strategie să fie încercarea;
  • memoryless: faptul că ai încercat deja un milion de nonce-uri nu te apropie de soluție. Fiecare încercare are aceeași șansă.

Diferența față de Bitcoin: acolo nu se numără zerouri hex, ci hash-ul (ca număr de 256 de biți) trebuie să fie sub o țintă, care poate fi orice valoare, nu doar o putere a lui 16. Asta permite ajustări fine ale dificultății. Și se hash-uiește antetul binar de 80 de bytes cu double SHA-256.

Ce urmărește intervievatorul: Este codul clasic din curs. Se verifică dacă știi să estimezi costul, nu doar să scrii bucla, și dacă înțelegi caracterul probabilist al minării.

Eroarea, în practică:Minarea nu găsește niciun nonce'<' not supported between 'str' and 'int'

47 Junior

Ce înseamnă „dificultate” în Bitcoin și de ce rețeaua o schimbă? Ce s-ar întâmpla dacă ar fi fixă?

Răspuns scurt: Dificultatea arată cât de greu e să găsești un hash sub țintă, relativ la dificultatea minimă de la început. Rețeaua o ajustează ca timpul mediu între blocuri să rămână în jur de 10 minute, oricât de multă putere de calcul se adaugă sau se retrage.

Puterea de calcul a rețelei (hashrate) nu e constantă: minerii intră și ies, iar echipamentele devin mai eficiente. Dacă dificultatea ar fi fixă:

  • la creșterea puterii de calcul, blocurile ar veni din ce în ce mai repede. Emisiunea de monede s-ar accelera, iar programul de halving s-ar comprima;
  • blocuri mai dese înseamnă mai multe blocuri stale și securitate mai slabă, cum s-a discutat la propagare;
  • la scăderea puterii de calcul (de exemplu dacă minerii pleacă brusc), blocurile ar veni rar, iar rețeaua ar deveni practic inutilizabilă.

Dificultatea este raportul dintre ținta maximă (cea din blocul geneză) și ținta curentă: difficulty = max_target / current_target. Dificultate 1 înseamnă ținta inițială. O dificultate de un milion înseamnă că, în medie, e nevoie de un milion de ori mai multe hash-uri.

Relația utilă: numărul mediu de hash-uri pentru un bloc este aproximativ difficulty × 2^32. Dacă cunoști dificultatea și timpul mediu între blocuri, poți estima puterea de calcul totală a rețelei, chiar dacă nimeni nu o raportează.

Dificultatea se recalculează la fiecare 2016 blocuri. Nu există un calcul centralizat: fiecare nod aplică aceeași formulă pe aceleași timestamp-uri și obține aceeași valoare, iar un bloc care declară altă dificultate este invalid.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de autoreglare a rețelei. Greșeala tipică este credința că dificultatea crește automat în timp, indiferent de puterea de calcul.

48 Junior

Ce câmpuri conține antetul unui bloc Bitcoin și de ce minerii hash-uiesc doar antetul, nu tot blocul?

Răspuns scurt: Antetul are 80 de bytes: version (4), hash-ul blocului anterior (32), rădăcina Merkle (32), timestamp (4), bits, adică ținta compactă (4), și nonce (4). Tranzacțiile sunt reprezentate prin rădăcina Merkle, deci hash-ul antetului le acoperă pe toate.

câmp          bytes   rol
version         4     versiunea regulilor; biți folosiți la semnalizarea soft fork-urilor
prev_block     32     hash-ul antetului anterior: legătura din lanț
merkle_root    32     rezumatul tuturor tranzacțiilor din bloc
time            4     timestamp Unix, cu regulile MTP și limita de 2 ore
bits            4     ținta, în format compact
nonce           4     valoarea variată de miner

Toate câmpurile numerice sunt little-endian.

De ce doar antetul:

  • eficiență: fiecare încercare de minare cere un double SHA-256 pe 80 de bytes, nu pe un bloc de ordinul megabyților;
  • acoperire completă: rădăcina Merkle angajează toate tranzacțiile; orice modificare a lor schimbă rădăcina și deci hash-ul antetului;
  • noduri ușoare: un client SPV poate valida lanțul de Proof of Work având doar antetele.

Câmpul prev_block creează lanțul: dacă modifici un bloc vechi, hash-ul lui se schimbă, deci câmpul prev_block din blocul următor nu mai corespunde, și tot așa până la vârf. Pentru a rescrie istoria trebuie re-minate toate blocurile de după.

Antetul nu conține înălțimea blocului, numărul de tranzacții sau hash-ul propriu. Înălțimea apare în tranzacția coinbase (BIP34), iar hash-ul se calculează de oricine din antet.

Un detaliu bun pentru interviu: cei 4 bytes de nonce dau doar circa 4,3 miliarde de variante, epuizate rapid de un ASIC; minerii variază și alte câmpuri.

Ce urmărește intervievatorul: Se verifică dacă știi structura reală a blocului și legătura dintre antet și tranzacții. Mulți candidați cred că antetul conține lista tranzacțiilor sau hash-ul blocului curent.

Eroarea, în practică:'I' format requires 0 <= number <= 4294967295unpack requires a buffer of 4 bytes

49 Junior

Scrie funcția block_subsidy(height) care întoarce recompensa în satoshi la o anumită înălțime. De ce oferta totală de bitcoini este puțin sub 21 de milioane, nu exact?

Răspuns scurt: Subvenția inițială este 50 BTC (5.000.000.000 sat) și se înjumătățește la fiecare 210.000 de blocuri: 5_000_000_000 >> (height // 210_000). Oferta e puțin sub 21 de milioane pentru că înjumătățirea se face pe întregi în satoshi, cu rotunjire în jos.

PYTHON
HALVING_INTERVAL = 210_000
INITIAL_SUBSIDY = 50 * 100_000_000      # în satoshi

def block_subsidy(height: int) -> int:
    halvings = height // HALVING_INTERVAL
    if halvings >= 64:
        return 0
    return INITIAL_SUBSIDY >> halvings

def total_supply() -> int:
    total, h = 0, 0
    while (s := block_subsidy(h)) > 0:
        total += s * HALVING_INTERVAL
        h += HALVING_INTERVAL
    return total

print(block_subsidy(0), block_subsidy(210_000), block_subsidy(840_000))
print(total_supply() / 100_000_000)

Prima linie afișează 5000000000 2500000000 312500000. Deplasarea la dreapta cu un bit (>>) este împărțirea întreagă la 2.

De ce sub 21 de milioane: seria 50 + 25 + 12,5 + ... ar tinde exact la 100, deci 210.000 × 100 = 21.000.000. Dar în satoshi, după câteva zeci de înjumătățiri, valorile impare se rotunjesc în jos (de exemplu 9 >> 1 = 4), iar după 33 de înjumătățiri subvenția ajunge la 0. Rotunjirile pierdute fac totalul puțin sub 21 de milioane. În plus, unele monede sunt nerevendicabile (de exemplu ieșirea coinbase a blocului geneză nu poate fi cheltuită).

Verificarea halvings >= 64 vine din Bitcoin Core: în C++, o deplasare cu 64 de biți sau mai mult pe un întreg de 64 de biți este comportament nedefinit. În Python nu e necesară, dar arată că ai citit sursa reală.

Ce urmărește intervievatorul: Exercițiu de cod din lecția despre halving. Se verifică lucrul cu întregi și înțelegerea aritmeticii care fixează oferta.

50 Junior

De ce minerii se grupează în pool-uri de minare? Cum își împart recompensa și ce risc creează asta pentru rețea?

Răspuns scurt: Un miner mic găsește rar un bloc, deci veniturile lui ar fi imprevizibile. În pool, minerii trimit „shares” (soluții la o dificultate mai mică) care dovedesc munca, iar recompensa se împarte proporțional. Riscul: concentrarea deciziilor în câteva pool-uri.

Minarea este o loterie: probabilitatea de a găsi un bloc e proporțională cu puterea ta de calcul. Un miner cu o fracțiune minusculă din rețea poate aștepta, în medie, ani pentru un bloc, iar în realitate poate să nu găsească niciunul. Câștigul mediu e același, dar varianța e enormă.

Cum funcționează un pool:

  • operatorul construiește șablonul blocului (tranzacțiile, coinbase cu adresa pool-ului) și îl trimite minerilor;
  • minerii caută hash-uri sub o țintă mult mai ușoară decât cea a rețelei. Fiecare astfel de hash este un share și dovedește o anumită cantitate de muncă;
  • din când în când, un share este și sub ținta reală: e un bloc valid, iar pool-ul primește recompensa;
  • plata se face după număr de share-uri, cu scheme precum PPS (plată fixă per share, pool-ul preia riscul) sau PPLNS (împărțire din ultimele N share-uri când se găsește un bloc).

Minerii nu pot fura blocul: adresa din coinbase e a pool-ului, iar schimbarea ei ar schimba rădăcina Merkle și ar invalida munca.

Riscul: operatorul pool-ului alege tranzacțiile. Dacă puține pool-uri controlează majoritatea puterii, pot cenzura tranzacții sau se pot coordona. Minerii individuali pot schimba pool-ul, ceea ce limitează abuzurile, dar nu le exclude.

Răspunsuri tehnice: protocolul Stratum V2, care permite minerilor să-și construiască singuri șablonul de bloc, și pool-uri descentralizate.

Ce urmărește intervievatorul: Verifică înțelegerea economiei minării și a efectelor ei asupra descentralizării. Mulți candidați confundă pool-ul de minare cu deținerea puterii de calcul.

51 Junior

De ce minarea Bitcoin se face astăzi aproape exclusiv cu ASIC-uri și nu cu procesoare sau plăci video? Ce consecințe are?

Răspuns scurt: SHA-256 e simplă, nu cere multă memorie și se poate implementa direct în siliciu. Un ASIC face doar asta, mult mai eficient energetic decât un CPU sau un GPU. Minarea a devenit o industrie specializată, cu hardware nereutilizabil.

Evoluția minării Bitcoin a trecut prin patru etape: CPU (2009), GPU (din 2010, prin paralelism masiv), FPGA și apoi ASIC (Application-Specific Integrated Circuit, din 2013).

De ce câștigă ASIC-ul la SHA-256:

  • funcția folosește doar operații pe 32 de biți (adunări, rotații, XOR) și o stare internă mică; nu are nevoie de memorie mare;
  • un cip dedicat poate pune foarte multe nuclee de SHA-256 în paralel, fără nimic din ce face un procesor general (cache, predicție de salt, sistem de operare);
  • măsura relevantă este energia per hash (J/TH); la ea, diferența dintre generații de ASIC e mare, iar între ASIC și GPU e de ordine de mărime.

Consecințe:

  • barieră la intrare: minarea profitabilă cere hardware specializat și electricitate ieftină, deci se concentrează în anumite regiuni și firme;
  • securitate: hardware-ul nu e bun la altceva, deci minerii au un interes pe termen lung ca rețeaua să funcționeze; un atacator ar trebui să producă sau să cumpere cantități uriașe de ASIC-uri;
  • reciclare: echipamentele vechi devin inutile când apar generații mai eficiente.

Alte rețele au ales funcții „rezistente la ASIC”, care cer multă memorie (Scrypt la Litecoin, Ethash la Ethereum înainte de The Merge, RandomX la Monero). În practică, pentru Scrypt și Ethash au apărut tot ASIC-uri; RandomX, optimizat pentru CPU, a rezistat mai bine. Ethereum a renunțat complet la minare în 2022, prin trecerea la Proof of Stake.

Ce urmărește intervievatorul: Se verifică înțelegerea economiei minării din lecția despre minarea în lumea reală. Răspunsul bun leagă proprietățile funcției hash de hardware.

52 Mid

Ce este ținta (target) în Bitcoin și cum se decodează câmpul compact bits din antet? Scrie funcția.

Răspuns scurt: Ținta este numărul de 256 de biți sub care trebuie să fie hash-ul antetului. Câmpul bits o codează compact: primul byte e exponentul, ceilalți trei coeficientul, iar target = coeficient × 256^(exponent − 3).

Un hash de bloc este valid dacă, interpretat ca număr întreg de 256 de biți (little-endian), este mai mic sau egal cu ținta. O țintă mai mică înseamnă mai puține hash-uri acceptabile, deci dificultate mai mare.

Ca să nu ocupe 32 de bytes în antet, ținta e codată în 4 bytes, într-un format similar cu notația științifică:

PYTHON
def bits_to_target(bits: int) -> int:
    exponent = bits >> 24
    coefficient = bits & 0x007FFFFF
    if bits & 0x00800000:
        raise ValueError("ținta negativă nu e validă")
    if exponent <= 3:
        return coefficient >> (8 * (3 - exponent))
    return coefficient << (8 * (exponent - 3))

def hash_meets_target(header_hash: bytes, bits: int) -> bool:
    return int.from_bytes(header_hash, "little") <= bits_to_target(bits)

MAX_TARGET = bits_to_target(0x1d00ffff)   # ținta blocului geneză

Pentru 0x1d00ffff: exponentul este 0x1d (29), coeficientul 0x00ffff, deci ținta este 0xffff urmat de 26 de bytes de zero. Aceasta este ținta de dificultate 1.

Detalii:

  • bitul 0x00800000 este bit de semn, moștenit din formatul OpenSSL; coeficientul nu are voie să-l aibă setat;
  • formatul pierde precizie: ținta exactă calculată la ajustare se rotunjește la ce încape în 3 bytes de coeficient;
  • de aici vine și diferența între a compara „numărul de zerouri” (cum se face didactic) și compararea numerică cu ținta, care permite orice valoare intermediară.

Hash-ul ca număr little-endian explică de ce, afișat inversat, începe cu zerouri.

Ce urmărește intervievatorul: Verifică trecerea de la modelul didactic cu zerouri la mecanismul real. Candidații care n-au lucrat cu antete reale nu știu de câmpul bits.

Eroarea, în practică:'<' not supported between 'str' and 'int'Ținta PoW greșită: / în loc de //

53 Mid

Scrie funcția de ajustare a dificultății Bitcoin la fiecare 2016 blocuri. Ce limite are și ce defect cunoscut conține formula originală?

Răspuns scurt: Noua țintă este ținta veche înmulțită cu timp_real / timp_așteptat, unde timpul așteptat e de două săptămâni, iar factorul e limitat între 1/4 și 4. Defectul cunoscut: timpul real se măsoară pe 2015 intervale, nu pe 2016.

PYTHON
TARGET_SPACING = 10 * 60                     # 10 minute
INTERVAL = 2016
TARGET_TIMESPAN = INTERVAL * TARGET_SPACING   # 2 săptămâni
MAX_TARGET = 0xffff << (8 * 26)

def retarget(old_target: int, first_time: int, last_time: int) -> int:
    actual = last_time - first_time
    actual = max(TARGET_TIMESPAN // 4, min(actual, TARGET_TIMESPAN * 4))
    new_target = old_target * actual // TARGET_TIMESPAN
    return min(new_target, MAX_TARGET)

Logica: dacă ultimele 2016 blocuri au venit în o săptămână în loc de două, timpul real e jumătate, deci ținta se înjumătățește și dificultatea se dublează.

Limitele:

  • factorul este limitat la intervalul [1/4, 4] per ajustare, ca un salt brusc al puterii de calcul (sau un timestamp fals) să nu schimbe extrem dificultatea;
  • ținta nu poate depăși ținta maximă, deci dificultatea nu scade sub 1;
  • rezultatul se rotunjește la formatul compact bits.

Defectul off-by-one: Bitcoin Core calculează actual ca diferența dintre timestamp-ul ultimului bloc din perioadă și al primului bloc din aceeași perioadă. Asta acoperă 2015 intervale, nu 2016. Efectul asupra timpului mediu e mic, dar perioadele nu se suprapun, ceea ce face posibil atacul time warp: un miner majoritar poate manipula timestamp-urile de la granița perioadelor ca să scadă artificial dificultatea. Corectarea ar cere un soft fork, discutat în propunerea Consensus Cleanup.

Alte rețele folosesc ajustare la fiecare bloc (de exemplu medii mobile ponderate), care reacționează mai repede la fluctuații de putere de calcul.

Ce urmărește intervievatorul: Exercițiu de cod din proiectul cursului. Se verifică dacă înțelegi direcția corectă a ajustării (țintă vs dificultate) și dacă știi limitele reale.

Eroarea, în practică:ZeroDivisionError: division by zero

54 Mid

Câmpul nonce din antet are doar 32 de biți. Ce face un miner când a încercat toate cele circa 4,3 miliarde de valori fără succes?

Răspuns scurt: Schimbă alte date care intră în hash: extraNonce din tranzacția coinbase (care schimbă rădăcina Merkle), timestamp-ul sau unii biți din câmpul version. Cu fiecare schimbare, spațiul de nonce-uri se poate parcurge din nou.

2^32 înseamnă puțin peste 4 miliarde de valori. Un ASIC modern face de ordinul trilioanelor de hash-uri pe secundă, deci epuizează nonce-ul într-o fracțiune de secundă. Iar la dificultatea actuală, un bloc cere în medie mult mai multe încercări decât 2^32. Deci minerii au nevoie de mai multă variație.

Surse suplimentare de variație:

  • extraNonce: scriptSig-ul tranzacției coinbase poate conține date arbitrare. Schimbarea unui contor acolo schimbă txid-ul coinbase, deci rădăcina Merkle, deci antetul. Recalcularea rădăcinii e ieftină: doar ramura coinbase, cu log2(n) hash-uri;
  • timestamp: poate fi incrementat, în limitele regulilor (peste mediana ultimelor 11 blocuri, maximum 2 ore în viitor);
  • version rolling (BIP320): câțiva biți din câmpul version sunt rezervați pentru variație de către hardware, fără să interfereze cu semnalizarea soft fork-urilor; folosirea lor a fost numită și „overt AsicBoost”;
  • ordinea tranzacțiilor sau setul de tranzacții, care schimbă tot rădăcina Merkle.

În practică, într-un pool, serverul trimite fiecărui miner un șablon cu un extraNonce diferit (prin protocolul Stratum), ca minerii să nu caute în același spațiu. Fiecare parcurge apoi nonce-urile și, eventual, biții de version.

Detaliu util: căutarea nu e „mai aproape de soluție” după ce ai epuizat un spațiu. Fiecare hash are aceeași probabilitate; schimbarea extraNonce-ului doar dă alte hash-uri de încercat.

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi dimensiunile reale ale minării și structura blocului. Candidații fără experiență cu datele reale cred că nonce-ul ajunge mereu.

Eroarea, în practică:'I' format requires 0 <= number <= 4294967295

55 Senior

Subvenția de bloc se înjumătățește la fiecare aproximativ patru ani. Ce problemă de securitate poate apărea pe termen lung, când minerii vor trăi în principal din comisioane?

Răspuns scurt: Dacă veniturile din comisioane sunt mici sau foarte variabile, bugetul de securitate (cât se plătește pentru Proof of Work) scade. Mai apare riscul de fee sniping: minerii pot fi tentați să re-mineze un bloc recent cu comisioane mari, în loc să construiască peste el.

Securitatea Proof of Work vine din costul de a produce blocuri. Minerii investesc în hardware și energie proporțional cu veniturile așteptate: subvenție plus comisioane. Cu fiecare halving, subvenția scade la jumătate; după aproximativ anul 2140, devine zero.

Probleme discutate în cercetare și în comunitate:

  • bugetul de securitate: dacă comisioanele nu compensează, puterea de calcul scade, iar costul unui atac de 51% scade odată cu ea;
  • variabilitate: comisioanele variază mult de la un bloc la altul. Un bloc care conține o tranzacție cu comision foarte mare devine o țintă;
  • fee sniping: când subvenția e neglijabilă, un miner poate câștiga mai mult încercând să înlocuiască blocul precedent (luând comisioanele lui) decât construind un bloc nou cu mempool-ul rămas. Dacă destui mineri fac asta, reorganizările devin dese și confirmările își pierd valoarea;
  • instabilitate fără subvenție: lucrări academice au arătat că, fără subvenție, strategii de minare egoistă sau de abandon al blocurilor cu mempool gol pot deveni profitabile.

Măsuri existente și propuse:

  • Bitcoin Core setează nLockTime al tranzacțiilor la înălțimea curentă, deci tranzacțiile noi nu pot fi incluse într-un bloc re-minat la o înălțime anterioară; asta reduce stimulentul pentru fee sniping;
  • o cerere constantă pentru spațiul de bloc, inclusiv din partea soluțiilor de layer 2, care fac tranzacții de deschidere, închidere și decontare;
  • dezbaterea rămâne deschisă; la interviu contează să arăți că înțelegi mecanismul, nu să dai o predicție.

Ce urmărește intervievatorul: Întrebare de senior despre stimulentele economice ale protocolului. Se verifică gândirea pe termen lung și capacitatea de a discuta o problemă nerezolvată fără afirmații categorice.

Consens, fork-uri și atacuri

Exersează capitolul cu exerciții reale: Curs blockchain online →
56 Junior

Ce înseamnă de fapt „consens” într-un blockchain public? Ce diferență este între regulile de validare și regula de alegere a lanțului?

Răspuns scurt: Consensul are două componente: regulile de validare, pe care fiecare nod le aplică independent fiecărui bloc, și regula de alegere a lanțului (fork choice), care decide între ramuri valide. Majoritatea puterii de calcul decide doar ordinea blocurilor valide, nu ce este valid.

Mulți spun „consensul înseamnă că minerii votează”. E doar jumătate din poveste.

Regulile de validare (consensus rules) sunt scrise în software-ul fiecărui nod: semnături corecte, fără dublă cheltuire, subvenție corectă, dimensiune maximă, Proof of Work suficient. Fiecare nod complet le verifică singur. Un bloc invalid este respins de toate nodurile oneste, chiar dacă a fost produs de un miner cu 99% din puterea de calcul.

Regula de alegere a lanțului (fork choice): dintre ramurile formate doar din blocuri valide, nodul alege una. În Bitcoin, ramura cu cea mai multă muncă cumulată. În Ethereum post-Merge, LMD-GHOST, combinat cu checkpoint-urile Casper FFG.

Împreună dau consensul Nakamoto: nodurile ajung la aceeași istorie fără să se cunoască și fără o autoritate centrală.

Consecințe practice:

  • minerii nu pot schimba regulile singuri; pentru asta e nevoie ca nodurile să ruleze software nou (fork);
  • dacă două implementări aplică regulile ușor diferit, rețeaua se poate rupe. De aceea Bitcoin are practic o singură implementare de referință, iar Ethereum testează intens compatibilitatea între clienți;
  • un nod care nu validează (de exemplu un SPV) se bazează pe faptul că alții validează.

Analogia din curs, cu registrul clasei: fiecare elev verifică singur că intrările respectă regulile, iar când există două versiuni, toți o urmează pe cea mai lungă.

Ce urmărește intervievatorul: Verifică o înțelegere conceptuală pe care multe răspunsuri superficiale o ratează. Greșeala tipică este ideea că majoritatea poate impune orice.

57 Junior

Un atacator controlează 51% din puterea de calcul a unei rețele Proof of Work. Ce poate face și ce nu poate face?

Răspuns scurt: Poate rescrie blocurile recente, face duble cheltuieli cu propriile monede și cenzura tranzacții. Nu poate fura monedele altora, nu poate crea monede peste subvenție și nu poate schimba regulile protocolului, pentru că nodurile resping blocurile invalide.

Cu majoritatea puterii de calcul, atacatorul poate produce o ramură cu mai multă muncă decât restul rețelei.

Ce poate face:

  • dublă cheltuire: trimite monede unui exchange, așteaptă confirmările, retrage altă monedă, apoi publică o ramură minată în secret în care tranzacția inițială nu există (sau monedele merg la el);
  • cenzură: refuză să includă anumite tranzacții și abandonează blocurile altor mineri care le includ;
  • reorganizări: anulează blocuri recente, făcând confirmările nesigure;
  • poate încasa toate recompensele, alungând alți mineri.

Ce nu poate face:

  • să cheltuie monedele altcuiva: ar avea nevoie de semnăturile cu cheile lor;
  • să creeze monede în plus sau să schimbe subvenția: blocul ar fi invalid pentru noduri;
  • să modifice tranzacții vechi fără să re-mineze tot de acolo până la vârf; cu cât sunt mai vechi, cu atât costă mai mult.

Atacuri de acest tip au avut loc în realitate pe rețele mai mici, cu putere de calcul redusă, de exemplu Ethereum Classic și Bitcoin Gold. Pe rețele mici, atacatorul poate închiria putere de calcul compatibilă de pe piețe de închiriere.

Apărarea practică pentru un serviciu: numărul de confirmări cerute se stabilește în funcție de rețea, de valoarea tranzacției și de cât ar costa un atac, nu printr-o valoare universală.

Ce urmărește intervievatorul: Se verifică dacă știi limitele atacului, nu doar numele lui. Greșeala tipică: „atacatorul poate lua banii oricui”.

58 Junior

Ce este un atac Sybil și de ce un blockchain public nu poate lua decizii prin votul „un nod, un vot”?

Răspuns scurt: Atacul Sybil înseamnă crearea multor identități false pentru influență disproporționată. Un nod se pornește gratuit, deci un atacator ar câștiga orice vot pe noduri. PoW și PoS leagă influența de o resursă costisitoare.

Numele vine de la o carte despre o persoană cu personalități multiple. În sisteme distribuite deschise, oricine se poate alătura fără aprobare și nu există o autoritate care să verifice că un participant este o persoană reală.

Dacă rețeaua ar decide istoria tranzacțiilor prin vot pe noduri, atacatorul ar porni oricâte noduri virtuale, pe câteva servere ieftine, și ar câștiga orice vot.

Soluția blockchain-urilor publice este să lege dreptul de a decide de o resursă rară:

  • Proof of Work: influența e proporțională cu puterea de calcul. Ca să ai de două ori mai multă, trebuie să plătești de două ori mai mult hardware și energie;
  • Proof of Stake: influența e proporțională cu monedele blocate ca garanție, care pot fi pierdute prin slashing;
  • Proof of Authority: identitățile sunt cunoscute și aprobate dinainte, deci problema e eliminată prin renunțarea la deschidere.

Atacuri Sybil rămân posibile la nivel de rețea P2P, chiar dacă nu afectează direct consensul:

  • un atacator cu multe noduri poate încerca să eclipseze o victimă;
  • poate observa propagarea tranzacțiilor ca să afle ce IP a emis o tranzacție;
  • poate trimite date invalide ca să consume resursele nodurilor.

Apărarea aici e diferită: limitarea conexiunilor din aceeași rețea, sistem de scor pentru vecini care se comportă rău și deconectarea lor.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există mecanismele de consens, nu doar cum funcționează. Răspunsul slab descrie atacul fără să-l lege de PoW și PoS.

59 Junior

Ce sunt Proof of Authority, Delegated Proof of Stake și Proof of History? În ce situații ai alege Proof of Authority?

Răspuns scurt: PoA: blocuri produse de validatori cunoscuți și aprobați. DPoS: deținătorii votează câțiva delegați care produc blocuri. PoH (Solana) e un ceas criptografic folosit împreună cu PoS. PoA se potrivește rețelelor private, de consorțiu și de test.

Proof of Authority (PoA): un set fix de validatori, identificați public (firme, instituții), semnează pe rând blocuri. Nu există minare și nici miză economică; garanția este reputația și eventual contractele dintre părți. Exemple: Clique în Geth, folosit istoric pe rețele de test ale Ethereum, și rețele de consorțiu.

  • avantaje: blocuri rapide, consum mic de energie, finalitate rapidă;
  • dezavantaj: încredere în validatori; un grup restrâns poate cenzura sau rescrie.

Delegated Proof of Stake (DPoS): deținătorii de monede votează delegați (de exemplu 21 la EOS), care produc blocuri prin rotație. E rapid, dar puterea se concentrează în câțiva producători, iar votul tinde să fie influențat de marii deținători.

Proof of History (PoH): Solana rulează un șir lung de hash-uri SHA-256, în care fiecare depinde de precedentul. Calculul nu se poate paraleliza, deci poziția în șir dovedește că a trecut un anumit timp. Evenimentele inserate în șir primesc o ordine verificabilă fără ca nodurile să comunice despre timp. Consensul propriu-zis e un mecanism PoS (Tower BFT).

Când ai alege PoA:

  • o rețea privată sau de consorțiu, unde participanții se cunosc și au contracte între ei;
  • o rețea de test sau de dezvoltare internă;
  • un proiect în care deschiderea nu e o cerință.

Întrebarea care trebuie pusă onest: dacă toți validatorii sunt cunoscuți și de încredere, ai nevoie de blockchain sau ajunge o bază de date replicată cu jurnal semnat?

Ce urmărește intervievatorul: Se verifică cunoașterea mecanismelor alternative din curs și judecata despre când se potrivește fiecare. Candidații confundă des PoH cu un mecanism de consens complet.

60 Junior

Doi mineri găsesc aproape simultan câte un bloc valid la aceeași înălțime. Ce se întâmplă în rețea și cum se rezolvă situația?

Răspuns scurt: Rețeaua se împarte temporar, fiecare nod minând peste blocul văzut primul. Când apare următorul bloc peste una dintre ramuri, toate nodurile trec pe ea. Tranzacțiile doar din blocul abandonat revin în mempool.

Este un fork temporar (accidental), diferit de un fork de protocol (soft sau hard fork), care apare din schimbarea regulilor.

Pașii:

  • minerul X găsește blocul A la înălțimea 100, minerul Y găsește blocul B tot la 100, înainte să afle de A;
  • ambele blocuri sunt valide. Nodurile din apropierea lui X primesc întâi A, cele din apropierea lui Y primesc întâi B;
  • regula din Bitcoin Core: dacă două ramuri au aceeași muncă, rămâi pe cea văzută prima. Deci rețeaua e împărțită;
  • un miner găsește blocul 101. Dacă l-a construit peste A, ramura A are acum mai multă muncă cumulată;
  • nodurile care erau pe B fac o reorganizare: deconectează blocul B și conectează A și 101.

Ce se întâmplă cu tranzacțiile:

  • tranzacțiile prezente în ambele blocuri rămân confirmate;
  • cele care erau doar în B revin în mempool și vor fi incluse, de regulă, într-un bloc viitor;
  • tranzacția coinbase a lui B dispare; minerul Y pierde recompensa. De aceea există maturitatea de 100 de blocuri.

De ce contează pentru aplicații: o tranzacție cu o singură confirmare poate fi temporar „neconfirmată” după o reorganizare. Un serviciu care procesează plăți trebuie să reacționeze la reorganizări și să nu considere o tranzacție definitivă după primul bloc.

Fork-urile de un bloc apar în mod natural; cele de două blocuri sunt mult mai rare, iar cele mai lungi indică de obicei o problemă de rețea sau un atac.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de bază din lecția despre fork-uri. Greșeala tipică este credința că tranzacțiile din blocul abandonat se pierd.

61 Mid

De ce regula Bitcoin nu este „cel mai lung lanț”, ci „lanțul cu cea mai multă muncă cumulată”? Scrie cum calculezi munca unui lanț.

Răspuns scurt: Pentru că lungimea se poate falsifica: un atacator ar putea produce rapid multe blocuri cu dificultate mică. Munca unui bloc este aproximativ 2^256 / (target + 1), adică numărul mediu de hash-uri necesar, iar munca lanțului este suma pe toate blocurile.

Whitepaper-ul vorbește de „cel mai lung lanț”, dar implementarea compară munca cumulată (chainwork). Diferența contează în special din cauza ajustării dificultății.

Scenariul de atac pentru varianta cu lungime: un atacator pornește o ramură privată dintr-un punct vechi, manipulează timestamp-urile ca dificultatea să scadă și produce mult mai multe blocuri ușoare decât lanțul real. Lanțul lui ar fi mai lung, dar ar reprezenta mult mai puțină muncă.

PYTHON
def block_work(target: int) -> int:
    return (1 << 256) // (target + 1)

def chain_work(targets: list[int]) -> int:
    return sum(block_work(t) for t in targets)

def better_chain(a: list[int], b: list[int]) -> str:
    wa, wb = chain_work(a), chain_work(b)
    if wa == wb:
        return "egal: păstrează lanțul văzut primul"
    return "a" if wa > wb else "b"

block_work estimează câte hash-uri trebuie încercate, în medie, ca să obții un hash sub țintă: probabilitatea unei încercări reușite e (target + 1) / 2^256. Bitcoin Core stochează valoarea nChainWork pentru fiecare bloc din index.

În proiectul din curs, unde toate blocurile au aceeași dificultate, „cel mai lung” și „cea mai multă muncă” coincid. Cu ajustarea dificultății, regula trebuie schimbată.

Detaliu: la egalitate de muncă, nodul rămâne pe ramura primită prima. Fără această regulă, nodurile ar putea oscila între ramuri echivalente.

Ce urmărește intervievatorul: Se verifică dacă înțelegi formularea exactă a regulii și de ce simplificarea din curs nu ajunge în producție.

Eroarea, în practică:Nodul acceptă un lanț mai lung, dar invalid

62 Mid

Ce este problema „nothing at stake” în Proof of Stake și cum o rezolvă protocoalele moderne?

Răspuns scurt: În PoS, a semna pe mai multe ramuri nu costă nimic, spre deosebire de PoW. Un validator rațional ar susține toate ramurile, iar fork-urile nu s-ar mai rezolva. Soluția este slashing-ul: semnăturile contradictorii duc la pierderea mizei.

În Proof of Work, un miner care minează pe două ramuri își împarte puterea de calcul: fiecare hash e încercat pe o singură ramură. Deci are un cost real să susții mai multe istorii, iar minerii aleg ramura cu cele mai mari șanse.

În Proof of Stake, producerea unui bloc sau a unui vot înseamnă doar o semnătură digitală, practic gratuită. Primele propuneri PoS aveau o problemă: dacă rețeaua se împarte, un validator rațional semnează pe ambele ramuri, ca să fie recompensat indiferent care câștigă. Dacă toți fac asta, nicio ramură nu e favorizată, iar un atacator poate susține o ramură alternativă la cost foarte mic.

Soluții folosite:

  • slashing: două semnături contradictorii de la același validator (de exemplu două blocuri diferite la același slot sau voturi incompatibile) sunt o dovadă criptografică. Oricine o poate include într-un bloc, iar validatorul își pierde o parte din miză și e eliminat;
  • miza blocată: validatorii depun monede care rămân blocate o perioadă și după ieșire, ca pedeapsa să poată fi aplicată și pentru fapte recente;
  • finalitate: după ce o majoritate calificată (două treimi din miză) a votat un checkpoint, revenirea cere ca cel puțin o treime din miză să fie tăiată.

Diferența fundamentală față de PoW: securitatea nu vine din costul extern (energie), ci din pierderea internă (miza), aplicabilă doar cât timp validatorul are fonduri în sistem. De aici vine problema înrudită a atacurilor pe termen lung (long-range).

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce PoS are nevoie de mecanisme pe care PoW nu le are. Răspunsul slab este „PoS e mai ecologic”, fără analiza stimulentelor.

63 Mid

Cum funcționează PBFT pe scurt și de ce sunt necesare cel puțin 3f + 1 noduri pentru a tolera f noduri bizantine?

Răspuns scurt: PBFT are trei faze: pre-prepare, prepare și commit, fiecare confirmată cu 2f + 1 mesaje. Cu n = 3f + 1, orice două cvorumuri de 2f + 1 au în comun cel puțin un nod onest, care nu confirmă două valori diferite.

PBFT (Practical Byzantine Fault Tolerance, Castro și Liskov, 1999) permite unui grup cunoscut de noduri să cadă de acord, chiar dacă o parte mint sau trimit mesaje contradictorii.

Fazele, pentru o cerere:

  • pre-prepare: liderul atribuie cererii un număr de ordine și îl trimite tuturor;
  • prepare: fiecare nod retransmite propunerea; un nod e „pregătit” când primește 2f + 1 mesaje de prepare potrivite (inclusiv al lui);
  • commit: nodul anunță că e pregătit; când primește 2f + 1 mesaje de commit, execută cererea;
  • dacă liderul e suspect (nu propune sau propune contradictoriu), nodurile declanșează o schimbare de vizualizare (view change) și aleg un lider nou.

De ce 3f + 1:

  • sistemul trebuie să progreseze chiar dacă f noduri nu răspund, deci poate aștepta cel mult n − f răspunsuri;
  • printre cele n − f răspunsuri, până la f pot fi de la noduri rău-intenționate, deci onești sunt n − 2f;
  • ca onești să fie majoritari în orice cvorum, n − 2f > f, adică n ≥ 3f + 1.

Cu n = 4, sistemul tolerează un nod defect. Cu n = 7, două.

Comparație cu consensul Nakamoto:

  • PBFT are finalitate imediată: o decizie luată nu se mai schimbă;
  • complexitatea mesajelor e pătratică, deci funcționează pentru zeci de noduri, nu pentru mii;
  • cere un set cunoscut de participanți.

Variante moderne (Tendermint/CometBFT, HotStuff) păstrează pragul de două treimi și reduc comunicarea.

Ce urmărește intervievatorul: Se verifică înțelegerea fundamentelor din teoria sistemelor distribuite. Mulți candidați știu cifra 3f + 1, dar nu pot explica de unde vine.

64 Senior

Cum se activează un soft fork în Bitcoin? Explică semnalizarea minerilor prin BIP9 și ce s-a întâmplat la activarea SegWit.

Răspuns scurt: Prin BIP9, minerii semnalizează un bit în câmpul version; la 95% din blocurile unei perioade de 2016, regulile se activează. La SegWit, semnalizarea a stagnat, iar presiunea UASF (BIP148) și compromisul BIP91 au dus la activare.

Un soft fork restrânge regulile: blocurile valide după regulile noi sunt valide și pentru nodurile vechi. Riscul e ca o parte din mineri să producă blocuri care încalcă regulile noi; dacă sunt majoritari, ar apărea o ruptură. De aceea activarea se coordonează.

BIP9 (version bits):

  • fiecare propunere primește un bit din câmpul version și o fereastră de timp;
  • minerii care au software-ul nou setează bitul;
  • la fiecare perioadă de 2016 blocuri, nodurile numără blocurile care semnalizează. Peste prag (95% pe mainnet), propunerea trece în starea „locked in”, iar după încă o perioadă devine activă;
  • dacă fereastra expiră, propunerea eșuează.

Cazul SegWit (2017): semnalizarea a rămas mult timp sub prag, din cauza dezacordurilor legate de mărimea blocurilor. Au urmat:

  • BIP148 (UASF): noduri ale utilizatorilor care urmau să respingă blocurile fără semnalizare după o anumită dată;
  • BIP91: un compromis prin care minerii au impus semnalizarea cu un prag mai mic;
  • SegWit a fost blocat în august 2017. În același timp, cei care voiau blocuri mai mari au creat Bitcoin Cash printr-un hard fork.

Lecția a influențat Taproot (2021), activat cu Speedy Trial: semnalizare cu prag de 90%, fereastră scurtă și activare la o înălțime fixă după blocare.

Ideea de fond, utilă la interviu: semnalizarea minerilor e un mecanism de coordonare, nu un vot. Validitatea o decid nodurile economice care rulează software-ul.

Ce urmărește intervievatorul: Întrebare de senior despre guvernanța protocolului. Se verifică dacă înțelegi rolul diferit al minerilor și al nodurilor, ilustrat de cel mai cunoscut episod.

65 Senior

Whitepaper-ul Bitcoin calculează probabilitatea ca un atacator cu o fracțiune q din puterea de calcul să ajungă din urmă lanțul onest după z confirmări. Scrie funcția și interpretează rezultatul.

Răspuns scurt: Funcția modelează progresul atacatorului cu o distribuție Poisson și folosește probabilitatea de recuperare (q/p)^k pentru fiecare deficit k. Pentru q < 0,5, probabilitatea scade exponențial cu z; pentru q ≥ 0,5, atacatorul reușește în cele din urmă cu certitudine.

Secțiunea 11 din whitepaper modelează cursa ca pe un mers aleator. Dacă atacatorul e cu k blocuri în urmă, probabilitatea ca el să recupereze vreodată este (q/p)^k pentru q < p, unde p = 1 − q.

Cât timp onestul produce z blocuri, numărul de blocuri produse în secret de atacator urmează aproximativ o distribuție Poisson cu media λ = z · q / p. Se adună, pentru fiecare număr posibil de blocuri ale atacatorului, probabilitatea să le fi produs înmulțită cu probabilitatea de a recupera restul:

PYTHON
import math

def attacker_success(q: float, z: int) -> float:
    p = 1.0 - q
    if q >= p:
        return 1.0
    lam = z * (q / p)
    total = 1.0
    for k in range(z + 1):
        poisson = math.exp(-lam)
        for i in range(1, k + 1):
            poisson *= lam / i
        total -= poisson * (1 - (q / p) ** (z - k))
    return total

for z in range(0, 11, 2):
    print(z, attacker_success(0.1, z))

Interpretare:

  • pentru un q fix sub 50%, probabilitatea scade exponențial cu numărul de confirmări; de aici convenția de a aștepta mai multe confirmări pentru sume mari;
  • cu cât q e mai aproape de 50%, cu atât trebuie mai multe confirmări pentru același nivel de risc;
  • la q ≥ 50% confirmările nu protejează.

Limitele modelului: ignoră avantajele de rețea, minarea egoistă și costul atacului. Analiza modernă compară valoarea tranzacției cu costul de a închiria puterea de calcul necesară.

Ce urmărește intervievatorul: Întrebarea verifică stăpânirea modelului probabilist din spatele confirmărilor și capacitatea de a-l critica. Puțini candidați au citit efectiv secțiunea 11 din whitepaper.

66 Senior

Ce este un atac long-range în Proof of Stake și ce înseamnă „weak subjectivity”?

Răspuns scurt: Atacatorul obține cheile unor foști validatori care și-au retras miza și construiește o istorie alternativă din trecut, fără risc de slashing. Apărarea este weak subjectivity: un nod nou pornește de la un checkpoint recent, de încredere.

În Proof of Work, rescrierea unei istorii lungi cere refacerea întregii munci, deci costul crește cu lungimea. În Proof of Stake, producerea blocurilor costă doar semnături. Dacă un atacator obține cheile private ale unor validatori care au avut majoritate cândva în trecut (de exemplu cumpărate ieftin de la foști validatori care și-au retras fondurile), poate semna o istorie alternativă care pornește din acel moment.

De ce slashing-ul nu ajută: miza acelor validatori a fost deja retrasă, deci nu mai e nimic de tăiat.

Un nod care e online permanent nu e păcălit: știe deja ce blocuri au fost finalizate și nu se întoarce sub un checkpoint final. Problema apare la un nod nou sau la unul offline de mult timp: vede două istorii, ambele semnate corect, și nu are un criteriu obiectiv din protocol pentru a alege.

Weak subjectivity: un nod nou are nevoie de o informație recentă dintr-o sursă externă de încredere, un checkpoint (hash-ul unei stări finalizate). Fereastra în care checkpoint-ul rămâne valid ține de perioada de retragere a mizei. În Ethereum, clienții de consens suportă checkpoint sync: pornesc de la o stare recentă descărcată de la un nod sau furnizor ales de operator.

Compromisul: PoW e „obiectiv” (oricine poate verifica de la geneză care lanț are cea mai multă muncă), PoS cere o încredere socială minimă la pornire. Apărătorii PoS argumentează că și în PoW utilizatorii descarcă software de undeva, deci încrederea externă există oricum.

Ce urmărește intervievatorul: Întrebare de senior despre diferențele fundamentale de securitate dintre PoW și PoS. Se verifică dacă știi problema și soluția practică din clienții de astăzi.

67 Senior

Ce este minarea egoistă (selfish mining) și de ce arată că Bitcoin nu este perfect „compatibil cu stimulentele” sub pragul de 50%?

Răspuns scurt: Minerul egoist ține secrete blocurile găsite și le publică strategic, ca minerii onești să irosească muncă. Lucrarea lui Eyal și Sirer (2013) arată că strategia poate aduce o cotă de blocuri peste cota de putere de calcul, chiar sub 50%.

Strategia, simplificat:

  • minerul egoist găsește un bloc și nu îl publică; continuă să mineze în secret peste el;
  • dacă găsește încă unul, are un avans de două blocuri; când onestul găsește un bloc, egoistul îl publică pe ale lui, iar rețeaua trece pe ramura lui, mai lungă;
  • dacă onestul găsește bloc cât egoistul are avans de unul, egoistul își publică imediat blocul și urmează o cursă; câștigă dacă suficienți mineri onești minează peste blocul lui (parametrul γ, care depinde de avantajul de rețea).

Rezultatul: o parte din munca minerilor onești ajunge în blocuri abandonate, deci cota de blocuri a egoistului în lanțul principal crește peste cota lui de putere de calcul. După următoarea ajustare de dificultate, asta înseamnă venit mai mare.

În modelul lucrării, pragul de profitabilitate depinde de γ: pentru γ = 0 este o treime din puterea de calcul, iar pentru un atacator cu avantaj de rețea mare poate fi mult mai mic. Concluzia teoretică: pragul de siguranță nu e simplu 50%.

De ce nu se vede des în practică:

  • un atac de acest tip e detectabil (multe blocuri stale, blocuri publicate în rafale);
  • ar distruge încrederea în pool-ul respectiv și valoarea monedelor pe care le minează;
  • presupune o putere de calcul mare, concentrată.

Contramăsuri propuse: alegerea aleatoare între ramuri egale ca muncă, ceea ce fixează γ la 1/2, și propagarea mai rapidă a blocurilor.

Ce urmărește intervievatorul: Întrebarea apare la roluri de cercetare sau protocol. Verifică dacă înțelegi că securitatea vine din stimulente, iar acestea au margini mai fine decât regula de 50%.

Ethereum ca platformă

68 Junior

Ce înseamnă „starea globală” (world state) în Ethereum? Ce câmpuri are un cont?

Răspuns scurt: Starea globală este o asociere între fiecare adresă și contul ei. Orice cont are patru câmpuri: nonce, balance, storageRoot (rădăcina storage-ului) și codeHash (hash-ul codului). Fiecare bloc trece starea dintr-o versiune în alta prin executarea tranzacțiilor.

Bitcoin păstrează setul de ieșiri necheltuite. Ethereum păstrează o stare: un tabel uriaș adresă → cont, actualizat de fiecare tranzacție. Un bloc este, conceptual, o funcție stare_nouă = aplică(stare_veche, tranzacții).

Câmpurile unui cont:

  • nonce: pentru un cont controlat de o cheie, numărul de tranzacții trimise; pentru un contract, numărul de contracte create de el;
  • balance: soldul, în wei (10^18 wei într-un ether);
  • storageRoot: rădăcina structurii care conține datele persistente ale contractului; pentru conturile fără cod e rădăcina unei structuri goale;
  • codeHash: hash-ul Keccak-256 al bytecode-ului; pentru conturile fără cod e hash-ul șirului vid.
PYTHON
from dataclasses import dataclass, field

@dataclass
class Account:
    nonce: int = 0
    balance: int = 0                       # wei
    storage: dict = field(default_factory=dict)
    code: bytes = b""

state: dict[str, Account] = {}

Rădăcina întregii stări (stateRoot) apare în antetul fiecărui bloc. Asta permite unui client să verifice soldul unui cont cu o dovadă criptografică, fără să aibă toată starea.

Diferența practică față de UTXO: o tranzacție nu „consumă monede”, ci modifică solduri și date. E mai simplu pentru aplicații, dar ordinea tranzacțiilor contează, iar execuția paralelă e mai greu de făcut.

Starea totală ocupă mult spațiu și crește constant; un nod complet o păstrează doar pe cea curentă (plus câteva versiuni recente), iar un nod arhivă păstrează toate versiunile istorice.

Ce urmărește intervievatorul: Verifică modelul mental de bază al Ethereum. Mulți candidați nu știu că soldul unui cont este doar un câmp în stare, nu un set de monede.

69 Junior

Ethereum este descris ca „un calculator mondial”. Ce înseamnă concret faptul că fiecare nod reexecută fiecare tranzacție și ce implicații are pentru cine construiește aplicații?

Răspuns scurt: Fiecare nod complet execută aceleași tranzacții, în aceeași ordine, și trebuie să obțină aceeași stare. Calculul nu e împărțit, ci repetat de toți. De aceea calculul și stocarea pe lanț sunt scumpe, iar aplicațiile pun pe lanț doar strictul necesar.

Metafora „calculator mondial” poate induce în eroare: nu e un supercalculator care împarte munca, ci un calculator foarte lent, ale cărui rezultate sunt verificate independent de mii de noduri.

Ce se întâmplă: o tranzacție care apelează un contract e executată de propunătorul blocului, apoi de fiecare nod care validează blocul. Toți trebuie să ajungă la aceeași stare; altfel blocul e respins.

Implicații pentru aplicații:

  • cost: fiecare operație e plătită în gas, pentru că e repetată de toată rețeaua. Calcule mari (procesare de imagini, machine learning) nu au ce căuta pe lanț;
  • stocare: datele scrise în starea permanentă trebuie păstrate de fiecare nod; sunt cea mai scumpă resursă. Fișierele mari stau în afara lanțului (IPFS, Arweave, servere), iar pe lanț rămâne un hash;
  • lipsa confidențialității: tot ce execută un contract e public, inclusiv datele de intrare;
  • determinism: codul nu poate citi ora exactă, nu poate face cereri HTTP și nu poate genera numere aleatoare sigure;
  • viteză: rezultatele sunt disponibile doar la includerea în bloc (în Ethereum, sloturi de 12 secunde) și devin finale mai târziu.

Ce primești în schimb: o execuție pe care nimeni nu o poate opri sau modifica, cu reguli publice și verificabile.

Tiparul practic: pe lanț pui logica de proprietate și transfer, iar restul (interfață, căutare, indexare, fișiere) stă în afara lui. Soluțiile de layer 2 mută execuția în altă parte și păstrează pe lanțul principal doar verificarea.

Ce urmărește intervievatorul: Verifică dacă ai o imagine realistă a costului și limitelor execuției pe lanț. Greșeala tipică este ideea că Ethereum e un cloud descentralizat pentru orice aplicație.

70 Junior

Ce este un smart contract la nivel de concept? De ce nu poate „afla singur” cursul unei valute sau vremea de mâine?

Răspuns scurt: Un smart contract este cod stocat la o adresă, executat de toate nodurile când o tranzacție îl apelează. Nu poate face cereri pe internet, pentru că toate nodurile trebuie să obțină același rezultat; datele externe vin prin tranzacții, de la oracole.

Termenul îi aparține lui Nick Szabo, din anii '90, dar sensul de azi e mai tehnic: un program care rulează pe un blockchain.

Caracteristici:

  • cod la o adresă: contractul este un cont cu cod; are sold și date proprii (storage);
  • reactiv: nu rulează singur, în fundal. Se execută doar când o tranzacție sau un alt contract îl apelează. Nu există cron sau temporizator nativ; o acțiune „la o dată” cere ca cineva să trimită o tranzacție atunci;
  • determinist: aceleași intrări și aceeași stare dau mereu același rezultat pe toate nodurile;
  • public și verificabil: bytecode-ul e vizibil oricui; codul sursă poate fi publicat și verificat pe exploratoare;
  • imutabil implicit: odată publicat, codul nu se schimbă; actualizările cer tipare speciale, cu riscuri proprii.

De ce nu poate citi date externe: dacă un contract ar face o cerere HTTP la un serviciu de vreme, nodurile ar executa cererea la momente diferite, ar primi răspunsuri diferite sau serviciul ar fi indisponibil pentru unele. Nu ar mai exista o stare comună. În plus, la reexecutarea istoricului peste ani, serviciul nu ar mai exista.

Soluția este ca datele să intre prin tranzacții: cineva le scrie pe lanț, iar de atunci fac parte din stare și oricine le poate citi. Problema devine cine are voie să scrie și de ce ar fi corecte datele. Aceasta este problema oracolului.

Pentru aplicații reale, „contract” e un termen înșelător: nu are în spate o instanță juridică, iar un bug în cod nu se poate contesta.

Ce urmărește intervievatorul: Întrebarea verifică înțelegerea limitelor execuției pe lanț, fundamentul pentru oracole. Candidații slabi cred că un contract poate apela orice API.

71 Junior

Deschizi o tranzacție Ethereum într-un explorer de blocuri. Ce câmpuri citești și ce îți spune fiecare dacă un utilizator reclamă că „banii n-au ajuns”?

Răspuns scurt: Te uiți la status (succes sau eșec), bloc și confirmări, from, to, valoare, gas folosit și taxa, nonce, datele de intrare și events (logs), inclusiv transferurile de tokeni. Ele arată dacă tranzacția a fost inclusă, dacă a reușit și unde au ajuns efectiv fondurile.

Ordinea în care ai verifica:

  • status și bloc: dacă tranzacția nu există, nu a fost difuzată sau a fost înlocuită. Dacă e „pending”, nu e inclusă încă. Dacă e într-un bloc, numărul de confirmări arată cât de recentă e;
  • status: succes sau eșec: o tranzacție eșuată (revert sau out of gas) apare în bloc, taxa e plătită, dar efectele sunt anulate. Utilizatorul vede „s-au luat bani” (taxa), dar transferul nu s-a făcut;
  • from și to: dacă to e un contract de token, valoarea în ETH poate fi 0, iar transferul real apare în events;
  • value: suma de ETH transferată direct;
  • events / logs: pentru tokeni, transferul apare ca event Transfer cu expeditor, destinatar și sumă. Exploratoarele le afișează separat, ca „token transfers”;
  • gas used și taxa: ce s-a plătit pentru execuție;
  • nonce: dacă utilizatorul are tranzacții blocate, o tranzacție cu nonce mai mic, încă în așteptare, le blochează pe celelalte;
  • input data: funcția apelată și parametrii, decodați dacă contractul e verificat.

Cauze frecvente pentru „n-au ajuns”:

  • tranzacția a fost trimisă pe altă rețea (alt L2 sau alt lanț decât cel al destinatarului);
  • tokenul a fost trimis la adresa contractului tokenului, nu la destinatar;
  • tranzacția a eșuat;
  • destinatarul nu vede tokenul în wallet pentru că nu l-a adăugat în interfață, deși soldul există.

Un răspuns structurat pe acești pași arată că poți face suport tehnic real, nu doar teorie.

Ce urmărește intervievatorul: Verifică abilitatea practică de a citi date de pe lanț, utilă în suport, dezvoltare și audit. Candidații uită că tranzacțiile eșuate apar și ele în bloc.

72 Mid

De ce are Ethereum nevoie de gas, iar Bitcoin nu? Leagă răspunsul de problema opririi (halting problem).

Răspuns scurt: EVM permite bucle, iar problema opririi spune că nu poți decide dinainte dacă un program se termină. Gas-ul pune un preț pe fiecare operație și o limită pe tranzacție, deci orice execuție se oprește. Bitcoin Script nu are bucle.

Problema opririi (Turing, 1936): nu există un algoritm care să decidă, pentru orice program și orice intrare, dacă programul se termină. Un nod Ethereum nu poate deci analiza un contract și garanta că apelul se va termina.

Fără o limită, un atacator ar putea trimite o tranzacție cu o buclă infinită, iar toate nodurile ar rămâne blocate executând-o.

Soluția Ethereum:

  • fiecare instrucțiune are un cost fix în gas; operațiile scumpe pentru noduri (scrierea în storage, crearea de contracte) costă mult mai mult decât aritmetica;
  • tranzacția declară o limită de gas (gasLimit), plătită dinainte la prețul ales;
  • execuția se oprește când gas-ul se termină. Efectele se anulează, dar gas-ul consumat rămâne plătit propunătorului (și ars, pentru taxa de bază), deci atacul are un cost real;
  • blocul are și el o limită totală de gas, care limitează munca de validare per bloc.

De ce Bitcoin nu are nevoie: Script nu are bucle, iar costul unei tranzacții e aproximativ proporțional cu dimensiunea ei, deci comisionul pe vbyte ajunge. Prețul plătit este pentru spațiu, nu pentru calcul.

O nuanță: EVM e „cvasi-Turing-complet”, tocmai pentru că gas-ul limitează orice execuție. Teoretic poate exprima orice calcul, dar practic doar cele care încap în limita blocului.

Gas-ul are și rol economic: prețul pe unitate e stabilit de cerere (EIP-1559), deci spațiul de execuție se alocă celor care îl plătesc.

Ce urmărește intervievatorul: Verifică dacă înțelegi motivul fundamental al existenței gas-ului, nu doar formula taxei. Răspunsurile slabe spun „gas-ul e comisionul” și se opresc acolo.

73 Mid

De ce execuția în EVM trebuie să fie strict deterministă? Ce operații obișnuite din programare lipsesc din acest motiv?

Răspuns scurt: Toate nodurile trebuie să obțină exact aceeași stare, altfel consensul se rupe. De aceea EVM nu are virgulă mobilă, acces la rețea, fișiere sau ceasul sistemului și nici aleator real. Lucrează doar cu întregi de 256 de biți.

Dacă două noduri execută aceeași tranzacție și obțin rezultate diferite, vor calcula rădăcini de stare diferite, iar unul va respinge blocul pe care celălalt îl acceptă. Rețeaua se rupe. Determinismul e deci o cerință de consens, nu de stil.

Ce lipsește intenționat:

  • virgulă mobilă: rezultatele float pot diferi ușor între procesoare, compilatoare și moduri de rotunjire. EVM are doar întregi de 256 de biți; zecimalele se simulează cu numere mari (de exemplu 18 zecimale fixe), cu împărțire întreagă;
  • rețea și fișiere: răspunsurile ar diferi între noduri și în timp;
  • ceas real: există doar block.timestamp, ales de propunătorul blocului în anumite limite, aceeași valoare pentru toate nodurile;
  • aleator real: orice sursă internă (hash-uri de bloc, timestamp, prevrandao după The Merge) e cunoscută sau influențabilă de cine produce blocul;
  • paralelism nedeterminist: tranzacțiile din bloc se execută în ordinea fixată de propunător.

Consecințe pentru cine scrie contracte, chiar fără detalii de limbaj:

  • ordinea operațiilor contează la împărțiri: a / b * c poate pierde precizie față de a * c / b;
  • datele externe vin doar prin tranzacții (oracole);
  • numerele aleatoare pentru loterii sau jocuri se iau din servicii de tip VRF sau scheme commit-reveal.

Un exemplu istoric relevant: clienți Ethereum diferiți au avut bug-uri care au produs rezultate diferite pentru aceeași tranzacție, iar rețeaua s-a împărțit temporar. De aceea există suite comune de teste pentru toți clienții.

Ce urmărește intervievatorul: Verifică dacă legi limitările EVM de cerința de consens. Candidații enumeră adesea lipsurile fără să poată explica motivul comun.

74 Mid

Ce sunt receipts, logs și filtrul Bloom din antetul unui bloc Ethereum? Cum găsește un client toate evenimentele unui contract fără să reexecute blocurile?

Răspuns scurt: Fiecare tranzacție produce un receipt cu status, gas cumulat și logs (evenimentele). Antetul conține rădăcina receipts-urilor și un filtru Bloom de 2048 de biți. Clientul testează filtrul și citește logs doar din blocurile candidate.

Receipt-ul este rezultatul execuției unei tranzacții:

  • status (1 succes, 0 eșec);
  • cumulativeGasUsed în bloc până la acea tranzacție;
  • logs: listă de evenimente; fiecare are adresa contractului emitent, până la 4 topics (primul este de obicei hash-ul semnăturii evenimentului) și date;
  • logsBloom: filtrul Bloom al acestor logs.

Receipts-urile nu sunt stocate în stare, ci într-o structură separată, a cărei rădăcină (receiptsRoot) intră în antet. Pot fi dovedite cu o dovadă Merkle, ca tranzacțiile.

Filtrul Bloom este o structură probabilistă: un vector de biți în care fiecare element setează câțiva biți calculați din hash-ul lui. La interogare:

  • dacă cel puțin unul dintre biți e 0, elementul sigur nu e prezent;
  • dacă toți sunt 1, elementul poate fi prezent (există fals-pozitive, dar niciodată fals-negative).
PYTHON
def bloom_may_contain(bloom: int, positions: list[int]) -> bool:
    return all(bloom >> p & 1 for p in positions)

Un client care caută toate evenimentele Transfer ale unui token parcurge antetele, testează filtrul și cere receipts doar pentru blocurile candidate. Asta stă la baza eth_getLogs.

Limitări practice: cu blocuri pline, filtrul de 2048 de biți se umple, iar fals-pozitivele devin frecvente; interogările pe intervale mari sunt lente, iar furnizorii RPC limitează intervalele. De aceea aplicațiile serioase folosesc indexere care salvează evenimentele într-o bază de date. Există propuneri de înlocuire a filtrului Bloom din antet cu alte structuri.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanicii din spatele evenimentelor, utilă pentru backend și indexare. Candidații știu de events, dar rar știu unde și cum sunt stocate.

75 Mid

Ce înseamnă account abstraction în Ethereum? Explică la nivel de concept ERC-4337 și EIP-7702.

Răspuns scurt: Account abstraction înseamnă ca regulile unui cont (cine semnează, cine plătește taxa, ce limite are) să fie definite prin cod. ERC-4337 o face prin contracte, fără schimbarea protocolului; EIP-7702 permite unui EOA să delege la cod de contract.

Inițial, Ethereum are două tipuri de conturi: cele controlate de o cheie privată (EOA), care pot iniția tranzacții, dar au reguli fixe (o singură cheie ECDSA, taxa plătită în ETH de același cont), și contractele, care au logică arbitrară, dar nu pot iniția tranzacții. Account abstraction încearcă să combine flexibilitatea contractelor cu capacitatea de a iniția operații.

ERC-4337 (pe mainnet din 2023):

  • utilizatorul semnează un UserOperation, nu o tranzacție obișnuită;
  • operațiile ajung într-un mempool separat, unde bundlers le adună și le trimit într-o singură tranzacție către un contract EntryPoint;
  • EntryPoint apelează contul-contract al utilizatorului, care își verifică singur semnătura după regulile proprii;
  • paymasters pot plăti taxa în locul utilizatorului sau o pot accepta în tokeni.

EIP-7702 (activat în upgrade-ul Pectra, 2025): un EOA poate semna o autorizare prin care contul lui execută codul unui contract ales. Adresa rămâne aceeași, dar capătă funcții de smart wallet.

Ce permit:

  • recuperare socială (prieteni sau dispozitive care pot schimba cheia);
  • semnături cu alte scheme (de exemplu passkeys, cu curba P-256);
  • operații grupate (aprobare și schimb într-un singur pas);
  • limite de cheltuieli și chei de sesiune pentru jocuri și aplicații.

Riscuri: o delegare către cod rău-intenționat poate goli contul, iar logica de validare devine o nouă suprafață de atac. Wallet-urile trebuie să arate clar ce autorizează utilizatorul.

Ce urmărește intervievatorul: Întrebarea arată dacă urmărești evoluția recentă a Ethereum și înțelegi motivația. Greșeala tipică este confuzia dintre account abstraction și un simplu multisig.

76 Senior

De ce Ethereum folosește un Merkle Patricia Trie pentru stare, și nu un arbore Merkle simplu ca Bitcoin pentru tranzacții? Ce probleme are această structură?

Răspuns scurt: Starea se modifică la fiecare bloc și se caută după adresă. Trie-ul permite căutări și actualizări în O(lungimea cheii), recalculând doar nodurile de pe drum, plus dovezi de prezență sau absență. Problemele: dovezi mari și multe citiri de disc.

Un arbore Merkle simplu, ca în Bitcoin, e bun pentru o listă fixă: tranzacțiile unui bloc nu se mai schimbă. Starea Ethereum e un dicționar uriaș, modificat în fiecare bloc, din care trebuie să poți:

  • găsi un cont după adresă;
  • actualiza câteva conturi fără să reconstruiești totul;
  • dovedi valoarea unui cont, sau că un cont nu există, față de stateRoot.

Merkle Patricia Trie combină:

  • un trie (arbore de prefixe): cheia (keccak256(adresă)) e parcursă nibble cu nibble (4 biți), deci drumul e determinat de cheie;
  • compresia Patricia: secvențele fără ramificații se comprimă în noduri de extensie;
  • hash-uri Merkle: fiecare nod e referit prin hash-ul codării lui (RLP), deci rădăcina angajează tot.

Tipuri de noduri: branch (16 copii plus o valoare), extension (prefix comun) și leaf (restul cheii și valoarea). Fiecare cont are propriul trie pentru storage, a cărui rădăcină e storageRoot.

Hash-uirea cheii are două efecte: distribuie uniform cheile (atacatorul nu poate crea ramuri foarte adânci) și fixează lungimea drumului.

Probleme:

  • dovezi mari: fiecare nivel cere până la 15 hash-uri vecine, deci o dovadă de stare are kilobytes; asta împiedică clienții fără stare (stateless);
  • I/O: o citire înseamnă mai multe accese aleatoare pe disc; clienții moderni păstrează în plus o reprezentare plată (snapshot) pentru citiri rapide;
  • creșterea stării.

Direcția de cercetare: Verkle trees sau arbori binari cu hash-uri, care reduc mult dimensiunea dovezilor.

Ce urmărește intervievatorul: Întrebare de senior despre structurile de date ale protocolului. Verifică dacă înțelegi de ce s-a ales structura și ce compromisuri motivează schimbările propuse.

Wallet-uri și chei

77 Junior

Ce conține de fapt un wallet de criptomonede? Unde „stau” monedele?

Răspuns scurt: Un wallet conține chei private (sau o sămânță din care se derivă) și software care construiește și semnează tranzacții. Monedele nu stau în wallet: stau pe blockchain, ca UTXO-uri sau solduri asociate unor adrese. Wallet-ul doar dovedește dreptul de a le cheltui.

Analogia cu un portofel fizic e înșelătoare. Un wallet seamănă mai mult cu un breloc de chei: cheile deschid ceva, dar nu sunt ceea ce deschid.

Ce face un wallet:

  • generează și păstrează cheile sau, la wallet-urile moderne, o singură sămânță (seed) din care derivă oricâte chei;
  • derivă adrese din cheile publice, pe care le afișează pentru primire;
  • calculează soldul interogând blockchain-ul: caută UTXO-urile care aparțin adreselor lui (Bitcoin) sau citește soldurile conturilor (Ethereum). Soldul nu e salvat în wallet, ci recalculat;
  • construiește și semnează tranzacții, apoi le trimite rețelei printr-un nod.

Consecințe practice:

  • dacă îți pierzi telefonul, dar ai fraza de recuperare, poți reface wallet-ul pe alt dispozitiv și vei vedea aceleași fonduri, pentru că ele sunt pe lanț;
  • dacă cineva îți află cheia privată sau fraza, poate cheltui fondurile de oriunde, fără să aibă dispozitivul tău;
  • același set de chei poate fi folosit simultan în mai multe aplicații compatibile;
  • un watch-only wallet conține doar chei publice (de exemplu un xpub) și poate afișa soldul și genera adrese, dar nu poate semna.

În proiectul din curs, portofelul e exact asta: o pereche de chei pe secp256k1, o funcție care derivă adresa și una care semnează tranzacții. Soldul se calculează parcurgând lanțul.

Ce urmărește intervievatorul: Verifică modelul mental corect, de la care pornesc toate celelalte întrebări despre securitate. Greșeala tipică: „monedele sunt salvate în aplicație”.

78 Junior

Care este diferența dintre un wallet custodial și unul non-custodial? Ce riscuri are fiecare?

Răspuns scurt: La un wallet custodial, cheile sunt la un furnizor (de obicei un exchange), iar tu ai doar un cont la el. La unul non-custodial, cheile sunt la tine. Custodialul te expune la falimentul, hack-ul sau blocarea furnizorului; non-custodialul te face singurul responsabil de păstrarea cheilor.

Custodial: deții de fapt o creanță față de un furnizor. Când „trimiți” între doi utilizatori ai aceluiași exchange, de obicei nu există nicio tranzacție pe blockchain, doar o modificare în baza de date internă.

  • avantaje: recuperarea contului prin e-mail și verificarea identității, interfață simplă, suport;
  • riscuri: insolvența furnizorului, furtul cheilor lui, înghețarea contului, folosirea fondurilor clienților fără acordul lor. Falimente precum Mt. Gox (2014) și FTX (2022) au lăsat clienții fără acces la fonduri, uneori ani de zile.

Non-custodial: tu deții cheile sau fraza de recuperare, iar wallet-ul e doar software.

  • avantaje: nimeni nu îți poate bloca fondurile, nu depinzi de solvabilitatea unei firme;
  • riscuri: pierderea frazei înseamnă pierderea definitivă a fondurilor; dacă ești păcălit să o dezvălui sau să semnezi o tranzacție rea, nu există nimeni care să anuleze.

Expresia din comunitate „not your keys, not your coins” rezumă diferența.

Variante intermediare:

  • multisig cu un co-semnatar (de exemplu 2 din 3 chei, una la un serviciu de recuperare);
  • MPC, unde cheia e împărțită între tine și furnizor;
  • smart wallet-uri cu recuperare socială.

În UE, furnizorii de servicii de custodie pentru criptoactive intră sub regulamentul MiCA, care cere autorizare și separarea activelor clienților. Reglementarea reduce riscul, dar nu schimbă natura relației: tot ai încredere într-o terță parte.

Ce urmărește intervievatorul: Întrebarea verifică înțelegerea relației de încredere, importantă pentru cine construiește produse. Răspunsul bun nu declară un tip „mai bun”, ci leagă alegerea de nevoile utilizatorului.

79 Junior

Ce este un hot wallet și ce este un cold wallet? Ce protejează concret un hardware wallet și ce nu protejează?

Răspuns scurt: Un hot wallet ține cheile pe un dispozitiv online, un cold wallet le ține offline. Un hardware wallet semnează într-un cip separat, deci cheia nu ajunge pe calculator. Nu te apără dacă aprobi o tranzacție greșită sau îți dezvălui fraza.

Hot wallet: aplicație pe telefon, extensie de browser, software pe server. Cheia stă într-o memorie la care pot ajunge malware-ul, extensiile rău-intenționate sau un atacator cu acces la sistem. E comod pentru sume mici și plăți frecvente.

Cold wallet: cheia nu atinge niciodată un dispozitiv online. Variante: hardware wallet, un calculator dedicat care nu e conectat la rețea, sau o copie pe hârtie (cu riscurile ei fizice).

Hardware wallet: un dispozitiv mic, cu un element securizat sau microcontroler, care:

  • generează cheia intern și nu o exportă niciodată;
  • primește tranzacția nesemnată de la calculator, o afișează pe ecranul propriu și o semnează doar după confirmare fizică;
  • trimite înapoi doar semnătura.

Ce protejează: un calculator compromis nu poate citi cheia și nu poate semna fără butonul apăsat.

Ce nu protejează:

  • dacă ecranul dispozitivului arată o adresă, iar tu nu o verifici, malware-ul poate înlocui destinatarul;
  • blind signing: pentru tranzacții complexe pe Ethereum, dispozitivul poate afișa doar date greu de înțeles; utilizatorul aprobă orbește o tranzacție care dă unui contract drept să-i cheltuie tokenii;
  • fraza de recuperare introdusă pe un site „de verificare” sau fotografiată în cloud;
  • furt fizic al frazei sau constrângere.

Practica de interviu pentru un serviciu cu fonduri mari: majoritatea în cold storage, cu multisig și proceduri de semnare, iar în hot wallet doar cât e necesar pentru retragerile curente.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de amenințări, nu doar a definițiilor. Candidații cred adesea că un hardware wallet face imposibilă orice pierdere.

80 Junior

Un utilizator vrea să trimită o sumă mare dintr-un wallet. Ce verificări ar trebui să facă înainte, și ce este „address poisoning”?

Răspuns scurt: Verifici adresa integral, rețeaua, tokenul, taxa și ce autorizează tranzacția, apoi trimiți întâi o sumă mică de test. Address poisoning: atacatorul îți pune în istoric o adresă asemănătoare, sperând că o vei copia din greșeală.

Tranzacțiile pe blockchain sunt ireversibile, deci verificarea se face înainte.

Lista practică:

  • adresa: o compari integral, din sursa de încredere (de exemplu confirmată de destinatar pe alt canal), nu din istoricul de tranzacții;
  • rețeaua: același tip de adresă (0x...) e valid pe Ethereum și pe multe L2 sau lanțuri compatibile. Trimiterea pe o rețea pe care destinatarul nu o folosește poate face fondurile greu sau imposibil de recuperat;
  • tokenul: există tokeni falși cu nume și simbol identice; verifici adresa contractului tokenului;
  • suma și unitatea: zecimalele diferă între tokeni;
  • ce semnezi: dacă wallet-ul cere o aprobare (approve sau permit) în loc de un transfer, citești ce drepturi dai și cui;
  • tranzacție de test: trimiți o sumă mică, confirmi primirea, apoi trimiți restul.

Address poisoning: atacatorul generează o adresă care are aceleași primele și ultimele caractere ca una cu care interacționezi des (se poate face prin forță brută pe câteva caractere). Apoi îți trimite o tranzacție de valoare zero sau foarte mică de pe acea adresă, ca să apară în istoricul tău. Mulți utilizatori copiază adresa din istoric și verifică doar capetele.

Alte atacuri asemănătoare: malware care înlocuiește adresa din clipboard și site-uri de phishing care imită aplicații cunoscute.

Pentru cine construiește wallet-uri: agendă de adrese cu etichete, avertismente pentru adrese noi sau asemănătoare și simularea tranzacției înainte de semnare.

Ce urmărește intervievatorul: Întrebarea apare la roluri de produs, suport și securitate. Verifică dacă gândești din perspectiva utilizatorului real și cunoști atacurile frecvente.

81 Mid

Cum se generează o frază de recuperare după BIP39? Ce rol are checksum-ul și ce face passphrase-ul opțional?

Răspuns scurt: Se generează 128–256 de biți de entropie, se adaugă un checksum din SHA-256, iar rezultatul se împarte în grupuri de 11 biți, fiecare un cuvânt din lista de 2048. Sămânța vine din PBKDF2-HMAC-SHA512; alt passphrase dă alt wallet.

Pașii BIP39:

  • entropie aleatoare: 128 de biți pentru 12 cuvinte, 256 pentru 24;
  • checksum: primii ENT / 32 biți din SHA-256(entropie), adică 4 biți pentru 128;
  • entropie + checksum = 132 de biți, împărțiți în 12 grupuri de 11 biți; fiecare grup e un index în lista de 2048 de cuvinte (2^11 = 2048);
  • sămânța: PBKDF2-HMAC-SHA512(parolă = fraza, salt = "mnemonic" + passphrase, 2048 de iterații), rezultat de 512 biți. Din ea, BIP32 derivă cheia master.
PYTHON
import hashlib, unicodedata

def seed_from_mnemonic(mnemonic: str, passphrase: str = "") -> bytes:
    m = unicodedata.normalize("NFKD", mnemonic).encode()
    salt = unicodedata.normalize("NFKD", "mnemonic" + passphrase).encode()
    return hashlib.pbkdf2_hmac("sha512", m, salt, 2048)

Rolul checksum-ului: detectează o greșeală de transcriere (un cuvânt greșit sau inversat). Nu e o protecție de securitate, ci de corectitudine.

Passphrase-ul (numit uneori „al 25-lea cuvânt”):

  • orice passphrase produce o sămânță validă, deci un alt wallet. Nu există „passphrase greșit”, doar un wallet gol;
  • protejează dacă fraza e găsită fizic; atacatorul are nevoie și de passphrase;
  • permite wallet-uri ascunse;
  • dacă îl uiți, fondurile sunt pierdute.

Detalii de interviu: fraza nu e cheia privată, ci o reprezentare a entropiei; lista de cuvinte e aleasă ca primele 4 litere să identifice unic cuvântul. Pentru Bitcoin Core și alte wallet-uri există și formate alternative (de exemplu descriptori), iar SLIP39 (Shamir) permite împărțirea frazei în bucăți.

Ce urmărește intervievatorul: Verifică stăpânirea tehnică a standardului din lecția despre seed phrase. Mulți candidați cred că cuvintele sunt chiar cheia privată sau că un passphrase greșit dă eroare.

82 Mid

Explică derivarea ierarhică BIP32 și calea m/44'/0'/0'/0/0. Ce înseamnă derivare hardened și de ce e periculos să dezvălui un xpub împreună cu o cheie privată copil?

Răspuns scurt: Din sămânță rezultă o cheie master și un chain code, iar copiii se derivă cu HMAC-SHA512. Calea BIP44: scop/monedă/cont/schimb/index. Derivarea hardened (cu apostrof) cere cheia privată; la cea normală, xpub-ul plus o cheie privată copil dezvăluie părintele.

BIP32: HMAC-SHA512(key = "Bitcoin seed", data = sămânța) dă 64 de bytes: primii 32 sunt cheia privată master, ultimii 32 sunt chain code. Cheia extinsă = cheie + chain code.

Derivarea unui copil cu indexul i:

  • normală (i < 2^31): HMAC-SHA512(chain_code, cheie_publică_părinte || i). Se poate face doar cu cheia publică extinsă (xpub), deci un server poate genera adrese noi de primire fără să aibă chei private;
  • hardened (i ≥ 2^31, notat cu '): HMAC-SHA512(chain_code, 0x00 || cheie_privată_părinte || i). Cere cheia privată.

Calea BIP44 m/44'/0'/0'/0/0:

  • 44' scopul (standardul BIP44); BIP84 folosește 84' pentru adrese SegWit native;
  • 0' moneda (0 Bitcoin, 60 Ethereum, conform SLIP44);
  • 0' contul;
  • 0 lanțul: 0 adrese de primire, 1 adrese de rest;
  • 0 indexul adresei.

Pericolul: la derivarea normală, cheia privată a copilului este k_copil = k_părinte + IL mod n, unde IL se calculează din xpub. Cine are xpub-ul părintelui și o singură cheie privată de copil normal calculează k_părinte = k_copil − IL, deci toate cheile din acea ramură.

De aceea nivelurile de sus (scop, monedă, cont) sunt hardened: chiar dacă o cheie de adresă scapă, nu se compromite tot wallet-ul.

Și un xpub singur e sensibil: dezvăluie toate adresele contului, deci tot istoricul și soldul.

Ce urmărește intervievatorul: Se verifică înțelegerea structurii pe care se bazează toate wallet-urile moderne și a riscului concret. Candidații știu calea, dar rar pot explica de ce există niveluri hardened.

83 Mid

Când ai folosi un wallet multisig (de exemplu 2 din 3) și când MPC? Ce compromisuri au?

Răspuns scurt: Multisig cere mai multe semnături, verificate de protocol pe lanț: transparent și standardizat, dar vizibil. MPC împarte o singură cheie între participanți și produce o semnătură obișnuită: portabil între rețele, dar dependent de implementări complexe.

Multisig (m din n): ieșirea sau contractul cere m semnături valide de la n chei.

  • Bitcoin: scripturi multisig (P2WSH) sau, cu Taproot, combinații de chei și scripturi;
  • Ethereum: smart contract wallet (de exemplu Safe), care verifică semnăturile în cod.

Avantaje: regula e aplicată de protocol, oricine o poate verifica; cheile pot fi la oameni și dispozitive diferite; dacă pierzi o cheie din 3, încă poți cheltui și muta fondurile.

Dezavantaje: tranzacțiile sunt mai mari (pe Bitcoin, înainte de Taproot), structura e vizibilă pe lanț, iar pe Ethereum fiecare rețea are nevoie de contractul instalat separat; schimbarea semnatarilor e o tranzacție.

MPC / TSS (threshold signatures): cheia privată nu există niciodată întreagă. Fiecare participant are o parte, iar printr-un protocol interactiv produc împreună o semnătură ECDSA sau Schnorr normală.

Avantaje: pe lanț arată ca un wallet obișnuit, merge pe orice rețea cu aceeași curbă, iar părțile se pot reîmprospăta fără să schimbi adresa.

Dezavantaje: protocoalele sunt complexe, au existat vulnerabilități în implementări; de obicei depinzi de un furnizor și de software proprietar; politica (cine aprobă ce) e aplicată în afara lanțului.

Când pe care:

  • o trezorerie de proiect sau de firmă pe Ethereum: smart contract multisig cu semnatari cunoscuți;
  • un individ care vrea siguranță pe Bitcoin: multisig 2 din 3 cu dispozitive diferite, în locuri diferite;
  • un custode instituțional cu multe rețele: adesea MPC, combinat cu politici și aprobări.

Ce urmărește intervievatorul: Întrebarea verifică judecata arhitecturală privind păstrarea cheilor. Un răspuns bun discută și operațiunile: cine semnează, unde stau cheile, cum se face recuperarea.

Scalare, poduri, oracole și stablecoins

Exersează capitolul cu exerciții reale: Curs blockchain online →
84 Junior

De ce Bitcoin nu își crește pur și simplu dimensiunea blocurilor ca să proceseze mai multe tranzacții?

Răspuns scurt: Blocurile mai mari cer mai multă bandă, stocare și procesare de la fiecare nod complet, deci mai puțini oameni pot rula unul. Propagarea lentă crește blocurile stale, în avantajul minerilor mari. Bitcoin a ales scalarea pe straturi.

Pare o soluție evidentă, dar are costuri asupra a ce face un blockchain valoros: faptul că oricine poate verifica singur regulile.

Costurile blocurilor mari:

  • noduri complete: fiecare nod descarcă, validează și stochează fiecare bloc. Dacă cerințele cresc mult, rularea unui nod devine accesibilă doar centrelor de date, iar utilizatorii ajung să aibă încredere în alții;
  • sincronizarea inițială: un nod nou trebuie să proceseze tot istoricul; cu blocuri mari, durează mult mai mult;
  • propagare: blocurile mari circulă mai lent, deci apar mai multe blocuri stale, ceea ce favorizează pool-urile mari și reduce securitatea;
  • setul UTXO: mai multe tranzacții creează mai multe ieșiri care trebuie păstrate.

Dezbaterea a fost intensă în 2015–2017 („block size wars”). Rezultatul: SegWit a crescut capacitatea prin weight, iar grupul care voia blocuri mai mari a creat Bitcoin Cash printr-un hard fork.

Aceasta e trilema în practică: poți câștiga capacitate cedând din descentralizare.

Alternativa aleasă de Bitcoin:

  • tranzacții mai eficiente (SegWit, Taproot, plăți în lot);
  • layer 2, în special Lightning, unde majoritatea plăților nu ajung pe lanț;
  • lanțul de bază ca strat de decontare.

Ethereum a ajuns la o concluzie asemănătoare, cu altă tehnică: rollups care publică date compacte pe L1.

La interviu e bine să prezinți argumentele ambelor tabere, fără să tratezi una ca evident greșită.

Ce urmărește intervievatorul: Verifică înțelegerea compromisurilor din spatele unei decizii controversate. Răspunsul slab ignoră costul pentru nodurile complete.

85 Junior

Cum funcționează Lightning Network la nivel de concept? Ce tranzacții ajung pe blockchain și ce riscuri are?

Răspuns scurt: Două părți blochează fonduri într-o ieșire 2 din 2 pe lanț, apoi schimbă între ele tranzacții semnate, nepublicate, care actualizează soldurile. Pe lanț ajung doar deschiderea și închiderea. Plățile fără canal direct trec prin intermediari, cu HTLC-uri.

Pașii unui canal:

  • deschidere: Ana și Dan creează o tranzacție care blochează fonduri într-o ieșire multisig 2 din 2 (sau echivalent Taproot). E pe lanț;
  • actualizări: fiecare plată înseamnă o nouă tranzacție de angajament (commitment) semnată de ambii, cu noua împărțire. Nu se publică; fiecare o păstrează și o poate publica oricând;
  • revocare: când trec la o stare nouă, își dau unul altuia un secret care pedepsește publicarea stării vechi. Dacă Ana publică o stare în care avea mai mult, Dan o poate dovedi și ia toate fondurile din canal;
  • închidere: cooperativă (o tranzacție semnată de amândoi) sau unilaterală (publici ultima stare și aștepți un timp de blocare).

Plăți prin rețea: dacă Ana are canal cu Bob, iar Bob cu Dan, Ana îl poate plăti pe Dan prin Bob. Se folosesc HTLC (Hash Time-Locked Contracts): plata e condiționată de dezvăluirea unui secret al cărui hash îl știe toată lumea; Dan dezvăluie secretul ca să-și ia banii, iar asta îi permite lui Bob să-și ia banii de la Ana. Bob nu poate fura pe drum.

Riscuri și limitări:

  • trebuie să urmărești lanțul ca să reacționezi dacă cealaltă parte publică o stare veche (sau să delegi unui watchtower);
  • lichiditatea e limitată de fondurile din canale, iar direcția contează;
  • deschiderea și închiderea costă comisioane pe lanț;
  • nodurile de rutare trebuie să fie online și au nevoie de chei „calde”.

Canalele de plată au fost practic posibile abia după rezolvarea maleabilității txid-ului prin SegWit.

Ce urmărește intervievatorul: Se verifică înțelegerea conceptului de layer 2 pe Bitcoin, din lecția despre Lightning. Candidații cred adesea că fiecare plată Lightning e o tranzacție pe lanț.

86 Junior

Care este diferența dintre un sidechain și un rollup din punctul de vedere al securității?

Răspuns scurt: Un sidechain are propriul consens și proprii validatori; dacă aceștia sunt compromiși, fondurile pot fi furate. Un rollup execută tranzacțiile în afara lanțului principal, dar publică datele și rezultatele pe L1, care poate verifica sau contesta, deci moștenește o mare parte din securitatea lanțului principal.

Sidechain: un blockchain separat, cu propriile reguli de consens, conectat la lanțul principal printr-un pod.

  • cine produce blocurile? validatorii sidechain-ului, adesea un grup mic;
  • dacă ei se înțeleg să fure sau produc o stare falsă, lanțul principal nu are cum să știe; podul acceptă ce spun ei;
  • exemple: Liquid pentru Bitcoin (o federație de membri), diverse lanțuri compatibile EVM cu validatorii lor.

Rollup:

  • tranzacțiile se execută în afara L1, de un operator (sequencer);
  • datele tranzacțiilor se publică pe L1, deci oricine poate reconstrui starea;
  • rezultatul e verificat de L1: prin dovezi de fraudă (optimistic rollup), în care oricine poate contesta o stare greșită într-o fereastră de timp, sau prin dovezi de validitate (ZK rollup), verificate matematic de un contract pe L1;
  • chiar dacă operatorul dispare sau minte, utilizatorii își pot retrage fondurile pe baza datelor publicate.

Întrebarea esențială: cine poate fura fondurile și cine poate bloca retragerile? La un sidechain, majoritatea validatorilor lui. La un rollup bine construit, nimeni, cât timp L1 funcționează și cel puțin o parte onestă poate contesta (la cele optimiste).

În practică, multe rollup-uri sunt încă în faze intermediare: au chei de upgrade sau un consiliu de securitate care poate schimba contractele, ceea ce reintroduce încredere. Site-uri precum L2BEAT clasifică rollup-urile pe niveluri (stages) după aceste criterii.

Ce urmărește intervievatorul: Verifică dacă poți evalua o soluție de scalare după modelul de încredere, nu după marketing. Greșeala tipică: „orice L2 e la fel de sigur ca Ethereum”.

87 Junior

Cum funcționează un pod (bridge) între două blockchain-uri? Ce este un token „wrapped”?

Răspuns scurt: Cel mai des prin lock-and-mint: activul se blochează pe lanțul A, iar pe lanțul B se emite un token echivalent, ars la întoarcere. Tokenul de pe B este „wrapped”: valorează cât timp originalul chiar e blocat și în siguranță.

Două blockchain-uri nu se pot vedea unul pe altul: un contract de pe Ethereum nu poate citi direct starea Bitcoin. Un pod este mecanismul care transmite mesaje între ele.

Modele:

  • lock-and-mint: blochezi BTC la o adresă controlată de pod, primești pe Ethereum un token (de exemplu un BTC „wrapped”). Când vrei înapoi, arzi tokenul, iar podul eliberează BTC;
  • burn-and-mint: pentru tokeni emiși nativ pe mai multe rețele, emitentul arde pe una și emite pe alta;
  • pool-uri de lichiditate: nu se mută activul, ci depui pe lanțul A și primești din rezerva podului pe lanțul B, de la furnizori de lichiditate.

Un token wrapped este un IOU: un drept asupra activului blocat. Riscuri:

  • dacă activul original e furat din pod, tokenul wrapped nu mai valorează nimic;
  • custodele podului (când e unul) poate îngheța sau pierde fondurile;
  • același activ poate avea mai multe variante wrapped, de la poduri diferite, care nu sunt interschimbabile.

Ce verifică podul: cineva trebuie să confirme pe lanțul B că depunerea s-a făcut pe A. Cine e acel cineva definește securitatea: un singur operator, un multisig, un set de validatori, sau un client ușor care verifică criptografic antetele lanțului A.

Pentru utilizatori, cel mai sigur pod este adesea cel nativ al unui rollup, care moștenește securitatea L1. Pentru lanțuri independente nu există un pod fără încredere suplimentară.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului și a riscului de bază, înainte de discuția despre atacuri. Mulți candidați nu știu că un token wrapped e o creanță.

88 Junior

Ce este problema oracolului și cum o abordează rețelele de oracole descentralizate?

Răspuns scurt: Blockchain-ul garantează corectitudinea calculelor interne, nu și a datelor din lumea reală. Oracolul aduce aceste date și, dacă e un singur furnizor, devine punctul slab al sistemului. Rețelele descentralizate agregă date de la operatori independenți.

Un contract de împrumut trebuie să știe prețul activelor depuse ca garanție. Un contract de asigurare agricolă trebuie să știe cât a plouat. Blockchain-ul nu poate afla singur aceste lucruri.

Problema oracolului: garanțiile blockchain-ului (nimeni nu poate modifica regulile sau istoricul) nu se extind la datele externe. Dacă oracolul minte, contractul execută corect o decizie greșită. „Garbage in, garbage out.”

Abordări:

  • un singur furnizor: simplu, dar ai încredere totală în el; poate fi compromis, poate cădea sau poate fi forțat;
  • rețele descentralizate de oracole (de exemplu Chainlink): mai mulți operatori independenți colectează datele din mai multe surse, iar contractul folosește un agregat (de obicei mediana), ca un singur operator să nu poată muta rezultatul;
  • modele push și pull: în push, oracolul actualizează periodic sau la variații mari; în pull, utilizatorul aduce o valoare semnată recent în tranzacția proprie;
  • oracole on-chain: prețuri derivate din schimburi descentralizate, de exemplu medii ponderate în timp (TWAP), mai greu de manipulat într-un singur bloc;
  • oracole optimiste: oricine propune un răspuns, iar alții îl pot contesta cu o garanție, cu un mecanism de arbitraj.

Întrebări de design: cât de des se actualizează datele, ce se întâmplă dacă valoarea e veche sau oracolul se oprește, cine plătește actualizările.

Un detaliu important: datele unui oracol pot fi corecte, dar sursa lor poate fi manipulată (de exemplu o piață cu lichiditate mică).

Ce urmărește intervievatorul: Verifică înțelegerea limitelor fundamentale ale blockchain-ului. Răspunsul slab descrie un oracol ca „un API pe blockchain”, fără problema încrederii.

89 Junior

Ce tipuri de stablecoins există și ce riscuri are fiecare? Ce înseamnă depeg?

Răspuns scurt: Stablecoin-urile garantate cu monedă fiat au rezerve la un emitent; cele garantate cu criptoactive au colateral pe lanț, de obicei peste valoarea emisă; cele algoritmice încearcă să mențină paritatea doar prin reguli de emisiune și ardere. Depeg înseamnă că prețul se îndepărtează de valoarea țintă.

Un stablecoin încearcă să urmărească valoarea unui activ de referință, de obicei dolarul american sau euro.

Garantate cu fiat (USDT, USDC, EURC):

  • emitentul ține rezerve (numerar, titluri de stat) și emite tokeni; utilizatorii verificați pot răscumpăra;
  • riscuri: încrederea în emitent și în rezerve, banca unde stau rezervele, înghețarea adreselor de către emitent (contractele au de regulă această funcție), reglementare;
  • în UE, MiCA le tratează ca e-money tokens și cere autorizare și rezerve.

Garantate cu criptoactive (de exemplu DAI):

  • utilizatorii blochează colateral (ETH sau alte active) într-un contract, peste valoarea împrumutată;
  • dacă valoarea colateralului scade sub un prag, poziția e lichidată automat;
  • riscuri: scăderi bruște care fac lichidările ineficiente, dependența de oracole de preț, bug-uri în contracte, colateral care include ea însăși stablecoins centralizate.

Algoritmice:

  • încearcă să mențină paritatea prin emisiune și ardere, de obicei cu un token pereche;
  • riscul principal este o spirală: când încrederea scade, mecanismul emite tot mai mult din tokenul pereche, care își pierde valoarea. Așa s-a prăbușit TerraUSD în 2022.

Depeg: prețul pe piață se abate de la paritate. Cauze: îndoieli despre rezerve, o problemă la banca de custodie, o lichidare în cascadă, lipsă de lichiditate. Pentru un sistem care folosește stablecoin-ul ca garanție, un depeg temporar poate declanșa pierderi permanente.

Pentru un dezvoltator, „stabil” nu înseamnă „fără risc”; contează cine poate îngheța fondurile și ce se întâmplă la un depeg.

Ce urmărește intervievatorul: Întrebarea verifică înțelegerea mecanismelor și a riscurilor, din lecția despre tokeni și stablecoins. Răspunsul bun nu face recomandări și nu prezintă vreun tip ca sigur.

90 Mid

De ce retragerea dintr-un optimistic rollup durează de obicei în jur de o săptămână, iar dintr-un ZK rollup mult mai puțin?

Răspuns scurt: Optimistic rollup-ul presupune stările corecte și lasă o fereastră de contestare pentru dovezi de fraudă; retragerea e finală doar după ea. ZK rollup-ul publică o dovadă de validitate verificată de contractul de pe L1, deci nu așteaptă contestații.

Optimistic rollup (Arbitrum, OP Stack):

  • sequencer-ul execută tranzacțiile și publică pe L1 datele și o rădăcină de stare;
  • L1 nu verifică execuția. Presupune că e corectă, de unde și numele;
  • există o fereastră de contestare, de obicei de ordinul a 7 zile, în care oricine rulează un nod poate demonstra, prin dovezi de fraudă (fault proofs), că o rădăcină e greșită. Dovada se reduce la reexecutarea pe L1 a unui singur pas contestat;
  • retragerile către L1 sunt finale doar după expirarea ferestrei.

De ce o fereastră atât de lungă: trebuie să lase timp contestatarilor să observe și să reacționeze chiar dacă cineva încearcă să-i cenzureze pe L1 sau rețeaua e aglomerată.

ZK rollup (zkSync, Starknet, Scroll, Linea):

  • operatorul generează o dovadă de validitate (SNARK sau STARK) că noua stare rezultă corect din cea veche și din tranzacții;
  • un contract de pe L1 verifică dovada; dacă trece, starea e corectă matematic, fără să aștepte contestații;
  • retragerea se poate finaliza după ce dovada e verificată, ceea ce poate dura de la minute la ore, în funcție de cât de des se generează dovezile.

Compromisuri: generarea dovezilor ZK e costisitoare computațional și complexă, iar compatibilitatea cu EVM a fost istoric mai greu de obținut. Optimistic rollups sunt mai simple, dar au fereastra de retragere.

Pentru utilizatori, există poduri rapide: un furnizor de lichiditate îți dă fondurile imediat pe L1, contra unei taxe, și preia el așteptarea.

Ce urmărește intervievatorul: Verifică diferența fundamentală dintre cele două tipuri de rollup, prin consecința ei practică. Candidații știu numele, dar rar pot explica motivul ferestrei.

91 Mid

Ce este sharding-ul la nivel de concept și de ce Ethereum a renunțat la sharding-ul de execuție în favoarea „data sharding” pentru rollups?

Răspuns scurt: Sharding înseamnă împărțirea rețelei în grupuri care procesează fiecare doar o parte din date sau tranzacții. Ethereum a renunțat la execuția pe shard-uri, greu de compus, și oferă în schimb rollup-urilor spațiu ieftin pentru date (danksharding).

Ideea clasică, din bazele de date: în loc ca fiecare nod să proceseze tot, împarți starea și tranzacțiile în shard-uri. Fiecare grup de validatori se ocupă de un shard, iar capacitatea totală crește cu numărul de shard-uri.

Probleme în blockchain:

  • securitate pe shard: dacă validatorii sunt împărțiți, un atacator poate concentra forțele pe un singur shard. Soluția e alocarea aleatoare și reîmprospătată a validatorilor;
  • comunicarea între shard-uri: o tranzacție care atinge conturi din shard-uri diferite cere mesaje asincrone, complicate pentru aplicații. Contractele care se apelează sincron devin greu de compus;
  • disponibilitatea datelor: fiecare shard trebuie să publice date pe care alții le pot verifica.

Planul inițial al Ethereum avea 64 de shard-uri cu execuție. În jurul anului 2020, roadmap-ul a devenit centrat pe rollups:

  • execuția se mută pe L2;
  • L1 se concentrează pe consens, decontare și disponibilitatea datelor;
  • „sharding”-ul rămâne doar pentru date: danksharding. Primul pas, proto-danksharding (EIP-4844, upgrade-ul Dencun din 2024), a introdus blobs, date ieftine păstrate temporar. Pasul următor, PeerDAS (upgrade-ul Fusaka), permite nodurilor să verifice doar eșantioane din blobs.

Alte rețele folosesc sharding complet, de exemplu Near, cu propria arhitectură.

Diferența de abordare la interviu: sharding-ul de execuție împarte calculul, iar data sharding face ieftină publicarea datelor necesare pentru ca alții (rollups) să facă calculul în afara L1.

Ce urmărește intervievatorul: Se verifică înțelegerea conceptului și a evoluției reale a Ethereum. Mulți candidați descriu planul vechi cu 64 de shard-uri ca fiind cel actual.

92 Mid

De ce podurile între blockchain-uri au fost ținta unor atacuri foarte mari? Cum compari modelele de încredere ale podurilor?

Răspuns scurt: Un pod concentrează într-un singur loc tot activul blocat, iar verificarea mesajelor între lanțuri e greu de făcut fără încredere. Atacurile au exploatat chei compromise și bug-uri de verificare sau inițializare. Modelele se compară după cine trebuie să fie onest.

De ce sunt ținte:

  • concentrarea valorii: tot ce s-a mutat prin pod e blocat într-un singur loc pe lanțul de origine; un singur bug sau o singură compromitere îl expune integral;
  • complexitate: podul trebuie să interpreteze evenimente de pe un alt lanț, cu alte reguli de finalitate și alte formate;
  • chei operaționale: multe poduri se bazează pe un grup mic de semnatari.

Exemple cunoscute din 2022:

  • Ronin: atacatorii au obținut controlul asupra unui număr suficient de chei ale validatorilor podului;
  • Wormhole: un bug în verificarea semnăturilor pe Solana a permis emiterea de tokeni fără depunerea corespunzătoare;
  • Nomad: o eroare la inițializarea unui contract a făcut ca mesaje nedovedite să fie acceptate, iar mulți utilizatori au copiat tranzacția atacatorului.

Modele de încredere, de la cel mai slab la cel mai puternic:

  • verificare externă: un multisig sau un set de validatori atestă evenimentele. Ai încredere că majoritatea lor e onestă și că cheile le sunt bine păstrate;
  • verificare optimistă: mesajele sunt acceptate după o perioadă de contestare, dacă un observator onest nu le contestă;
  • verificare nativă: un client ușor sau o dovadă ZK verifică pe lanțul destinație antetele și consensul lanțului sursă. Siguranța e apropiată de a lanțurilor înseși, dar e scump și complicat;
  • podul canonic al unui rollup, care moștenește securitatea L1.

Întrebări bune în evaluare: câte chei trebuie compromise, cine poate face upgrade contractelor, există limite de retragere pe interval de timp și un mecanism de pauză?

Ce urmărește intervievatorul: Întrebarea verifică abilitatea de a analiza riscul unei infrastructuri, nu doar de a-i descrie funcționarea. Răspunsul bun numește tipuri concrete de defecte.

93 Senior

Ce înseamnă disponibilitatea datelor (data availability) pentru un rollup? De ce nu ajunge să publici pe L1 doar rădăcina stării sau dovada ZK?

Răspuns scurt: Disponibilitatea datelor înseamnă că oricine poate obține datele necesare pentru a reconstrui starea. Fără ele, utilizatorii nu-și pot dovedi fondurile la retragere, iar fraudele nu pot fi contestate. O dovadă ZK arată că starea e corectă, nu care este.

Un rollup publică pe L1 un angajament (rădăcina stării) și, eventual, o dovadă. Întrebarea este: dacă operatorul dispare mâine, poate cineva să afle ce sold are fiecare utilizator?

Fără date:

  • optimistic rollup: o dovadă de fraudă cere reexecutarea tranzacțiilor. Dacă datele nu sunt publice, nimeni nu poate demonstra că rădăcina e greșită, iar securitatea dispare;
  • ZK rollup: dovada garantează că tranziția e corectă, dar dacă nu știi starea, nu poți construi dovada Merkle de care ai nevoie pentru o retragere forțată. Operatorul îți poate „ține ostatici” banii;
  • utilizatorii nu pot reconstrui starea ca să pornească un operator alternativ.

De aceea un rollup publică datele tranzacțiilor (comprimate) pe L1. Variante care țin datele în altă parte:

  • validium: date în afara lanțului, la un comitet (DAC); mai ieftin, dar ai încredere în comitet;
  • rollup-uri care folosesc straturi externe de DA (de exemplu Celestia sau EigenDA), cu propriile ipoteze de securitate.

Pe Ethereum:

  • inițial, datele erau publicate ca calldata, scumpă pentru că rămâne permanent în istoric;
  • EIP-4844 (Dencun, 2024) a introdus blobs: date atașate blocurilor, cu o piață de taxe separată, păstrate de noduri doar câteva săptămâni. Ajunge pentru ca oricine interesat să le descarce și să le arhiveze; angajamentul KZG din bloc permite verificarea lor ulterioară;
  • data availability sampling: nodurile verifică eșantioane aleatoare din date codate cu corecție de erori și obțin o probabilitate foarte mare ca toate datele să fie disponibile, fără să le descarce integral.

Ce urmărește intervievatorul: Întrebare de senior: verifică dacă înțelegi că securitatea unui rollup depinde de date, nu doar de dovezi. Mulți candidați cred că ZK elimină complet nevoia de date publice.

94 Senior

Majoritatea rollup-urilor au astăzi un singur sequencer. Ce riscuri creează asta și ce mecanisme le reduc?

Răspuns scurt: Un sequencer unic poate cenzura tranzacții, le poate reordona pentru profit (MEV) și poate opri rețeaua dacă se defectează. Mecanismele de reducere sunt includerea forțată prin L1, posibilitatea de a ieși direct prin L1 și planurile de descentralizare a ordonării tranzacțiilor.

Sequencer-ul primește tranzacțiile utilizatorilor, le ordonează, le execută, dă confirmări rapide („soft confirmations”) și publică loturi pe L1. Un singur operator face asta mai simplu și rapid, dar introduce riscuri:

  • cenzură: poate refuza tranzacțiile anumitor adrese;
  • liveness: dacă sequencer-ul cade, rollup-ul se oprește; au existat întreruperi reale la rollup-uri mari;
  • MEV: controlul ordinii tranzacțiilor permite front-running sau extragerea de valoare;
  • confirmări neoficiale: confirmarea rapidă e o promisiune; finalitatea reală vine când lotul e pe L1 și, la optimistic, după fereastra de contestare;
  • încredere operațională: cheile sequencer-ului, infrastructura, jurisdicția operatorului.

Mecanisme de reducere:

  • forced inclusion: utilizatorul trimite tranzacția direct într-un contract pe L1. Sequencer-ul e obligat să o includă după o întârziere; dacă nu, oricine o poate forța. Pe OP Stack prin depuneri pe L1, pe Arbitrum prin delayed inbox;
  • escape hatch: dacă rollup-ul e blocat de mult timp, utilizatorii pot retrage fondurile direct pe baza datelor publicate;
  • descentralizarea: sequencer-e rotative, sequencer-e partajate între rollup-uri, rollup-uri în care L1 ordonează tranzacțiile (based rollups);
  • criptare a mempool-ului sau ordonare echitabilă, împotriva MEV.

Ce cer de la o echipă care construiește pe un L2: să știe ce se întâmplă cu aplicația dacă sequencer-ul cade o oră. Exemplu: un protocol cu lichidări trebuie să trateze prețurile vechi și să aibă o perioadă de grație după repornire.

Ce urmărește intervievatorul: Verifică o înțelegere matură a riscurilor din L2-urile reale, dincolo de teorie. Candidații ignoră adesea diferența dintre confirmarea sequencer-ului și finalitate.

Situații practice

95 Junior

Ai scris în Python un blockchain simplu (blocuri, minare, validare). Ce teste cu pytest ai scrie și arată două dintre ele.

Răspuns scurt: Teste pentru calea normală (un lanț nou e valid, minarea respectă dificultatea) și, mai important, teste negative: modificarea unei tranzacții, ruperea legăturii dintre blocuri, un bloc nemined sau o tranzacție cu semnătură invalidă trebuie respinse.

Într-un blockchain, cele mai valoroase teste sunt cele care verifică faptul că atacurile sunt respinse. Fluxul fericit funcționează aproape mereu; regulile de validare sunt cele care se strică pe nesimțite.

PYTHON
import pytest
from academiachain import Blockchain   # clasa din proiect

@pytest.fixture
def chain():
    bc = Blockchain(difficulty=2)
    bc.add_block([{"from": "ana", "to": "dan", "amount": 5}])
    bc.add_block([{"from": "dan", "to": "ion", "amount": 2}])
    return bc

def test_lant_nou_valid(chain):
    assert chain.is_valid()

def test_modificarea_unei_tranzactii_e_detectata(chain):
    chain.blocks[1].transactions[0]["amount"] = 500
    assert not chain.is_valid()

def test_bloc_reminat_fara_legatura_e_respins(chain):
    chain.blocks[1].transactions[0]["amount"] = 500
    chain.blocks[1].mine(chain.difficulty)     # hash nou, valid ca PoW
    assert not chain.is_valid()                # blocul 2 indică hash-ul vechi

Al treilea test e important: arată că re-minarea unui singur bloc nu ajunge, pentru că blocurile de după rămân legate de hash-ul vechi.

Alte teste utile:

  • un bloc cu hash care nu respectă dificultatea;
  • o tranzacție semnată cu altă cheie decât a expeditorului;
  • cheltuirea aceluiași UTXO în două tranzacții;
  • conflict între două noduri: se alege lanțul valid cu mai multă muncă;
  • determinism: același bloc dă același hash pe rulări diferite.

Practică bună: dificultate mică în teste (1 sau 2), ca suita să ruleze în câteva secunde, și timestamp-uri fixe, ca rezultatele să fie reproductibile.

Ce urmărește intervievatorul: Verifică dacă gândești testarea din perspectiva atacatorului. Candidații juniori scriu de obicei doar teste care confirmă că lucrurile merg.

96 Junior

Un utilizator al aplicației tale îți scrie că a trimis criptomonede la o adresă greșită și cere să le „anulezi”. Cum îi răspunzi?

Răspuns scurt: Explici cu empatie și clar că o tranzacție confirmată e ireversibilă și nimeni nu o poate anula. Apoi verifici ce se poate face realist (de exemplu dacă adresa e a unui exchange) și îl avertizezi despre escrocii care promit recuperări.

Un model de răspuns structurat:

  • ascultă și confirmă faptele: cere txid-ul, rețeaua, adresa sursă și destinație. Verifici singur în explorer ce s-a întâmplat; uneori tranzacția nici nu e confirmată sau a eșuat, iar banii sunt încă la el;
  • explică direct: o tranzacție confirmată nu poate fi anulată de nimeni. Nu există bancă sau administrator; asta e chiar proprietatea care face sistemul rezistent la cenzură. Evită formulările vagi care dau speranțe false;
  • caută variante reale:
  • dacă adresa aparține unui exchange sau unui serviciu custodial, acesta poate returna voluntar fondurile, dacă utilizatorul dovedește tranzacția; îi spui să contacteze suportul lor;
  • dacă a trimis pe rețeaua greșită (de exemplu pe un L2 în loc de mainnet) la o adresă pe care o controlează el, fondurile se pot recupera importând aceeași cheie pe rețeaua respectivă;
  • dacă destinatarul e o persoană cunoscută, o poate contacta;
  • avertizează despre escroci: după astfel de incidente apar „servicii de recuperare” care cer bani în avans sau fraza de recuperare. Nimeni legitim nu cere fraza;
  • învață din incident: dacă greșeala e frecventă, propui în echipă îmbunătățiri în produs (verificarea adresei, avertismente pentru rețea, tranzacție de test).

Tonul contează: utilizatorul e stresat și poate să fi pierdut o sumă importantă pentru el. Fii empatic, dar nu promite ce nu poți face.

Ce urmărește intervievatorul: Întrebare comportamentală pentru roluri cu contact cu utilizatorii. Verifică onestitatea, empatia și cunoașterea limitelor reale ale tehnologiei.

97 Mid

Un client îți cere să construiești „un blockchain” pentru a ține evidența documentelor interne ale firmei. Cum ai analiza dacă blockchain-ul e soluția potrivită și cum i-ai explica concluzia?

Răspuns scurt: Întrebi câte părți scriu date, dacă se încred unele în altele, dacă există un operator acceptat de toți și dacă e nevoie de verificare publică. Dacă o singură firmă scrie și citește, o bază de date cu jurnal de audit semnat ajunge.

Un model de răspuns în pași:

  • înțelege problema reală: ce vrea clientul să obțină? De obicei e vorba de un istoric care nu poate fi modificat pe ascuns, de audit sau de încredere între parteneri;
  • întrebările de decizie:
  • cine scrie date? Dacă e o singură organizație, blockchain-ul nu adaugă încredere: aceeași organizație controlează toate nodurile;
  • participanții se încred unii în alții sau există o terță parte acceptată? Dacă da, o bază de date centrală e suficientă;
  • e nevoie ca persoane din afară să poată verifica istoricul fără să aibă încredere în firmă?
  • ce date sunt? Documente confidențiale nu se pun pe un lanț public;
  • explică alternativele:
  • o bază de date cu jurnal append-only și intrări semnate;
  • un lanț de hash-uri intern (aceeași idee ca un blockchain, fără consens distribuit);
  • ancorarea: publici periodic pe un blockchain public doar hash-ul (sau rădăcina Merkle) documentelor din ziua respectivă. Oricine poate verifica ulterior că un document exista la acea dată, fără să-i vadă conținutul. E ieftin și folosește punctul forte al blockchain-ului;
  • explică pe limba clientului: „Blockchain-ul rezolvă problema încrederii între părți care nu au încredere una în alta. Dacă singura parte sunteți voi, plătiți complexitate fără să primiți acel beneficiu.”

Recomandarea se încheie cu costuri, complexitate și ce câștigă concret, nu cu un „nu” sec. Un consultant bun propune soluția potrivită, chiar dacă e mai simplă decât ce s-a cerut.

Ce urmărește intervievatorul: Verifică judecata profesională și onestitatea față de client. Intervievatorii apreciază candidații care pot spune „nu aveți nevoie de blockchain” cu argumente.

98 Mid

Un utilizator spune că a trimis o tranzacție Bitcoin acum trei ore și încă nu e confirmată. Cum depanezi problema pas cu pas?

Răspuns scurt: Verifici în explorer dacă tranzacția există și e în mempool, compari rata comisionului cu cea curentă, apoi alegi: aștepți, RBF, CPFP din rest sau retransmiți dacă a dispărut. Nu retrimiți plata din alte monede.

Pașii, în ordine:

  • există tranzacția? Cauți txid-ul în unul sau mai multe exploratoare. Dacă nu apare nicăieri, probabil nu a fost difuzată (wallet offline, eroare la trimitere) sau a fost respinsă de noduri (comision sub minimul de retransmitere, ieșire dust, intrări deja cheltuite);
  • rata comisionului: compari sat/vB al tranzacției cu ce au tranzacțiile din blocurile recente și cu estimările curente. Dacă e mult sub, minerii o vor lua doar când mempool-ul se golește;
  • dependențe: dacă tranzacția cheltuie o ieșire a unei alte tranzacții neconfirmate, o blochează și părintele;
  • alegerea soluției:
  • dacă nu e urgent și rata e aproape de cea curentă, aștepți;
  • RBF: wallet-ul emite o versiune cu comision mai mare (inclusiv în Bitcoin Core 28+, unde full-RBF e implicit);
  • CPFP: cheltui ieșirea de rest cu un comision mare, ca pachetul să devină atractiv;
  • dacă tranzacția a expirat din mempool-ul nodurilor (Bitcoin Core o elimină după un timp), o poți retransmite sau construi una nouă cu aceleași intrări;
  • ce să nu faci: să trimiți din nou aceeași sumă din alte monede. Dacă ambele se confirmă, plătești de două ori.

Pentru destinatar (de exemplu un magazin): nu considera plata încasată până la confirmări, iar în aplicație afișează clar starea „în așteptare”.

Ca îmbunătățire în produs: estimare de comision din mempool, RBF activat implicit și un buton de accelerare a tranzacției.

Ce urmărește intervievatorul: Situație practică din suport și operațiuni. Se verifică o metodă structurată de depanare și cunoașterea instrumentelor reale, nu doar a teoriei.

99 Mid

Administrezi un nod Bitcoin Core care a rămas în urmă cu sute de blocuri și nu se mai sincronizează. Cum investighezi?

Răspuns scurt: Verifici starea cu bitcoin-cli getblockchaininfo (blocuri vs antete, progres), conexiunile cu getpeerinfo și getnetworkinfo, apoi resursele (disc, memorie, ceas) și jurnalul debug.log. În funcție de cauză: repari rețeaua, eliberezi spațiu, crești dbcache sau, la corupere, reconstruiești indexul.

Pași de investigare:

  • starea lanțului: bitcoin-cli getblockchaininfo. Compari blocks cu headers:
  • dacă headers e și el în urmă, nodul nu află de blocuri noi: problemă de rețea;
  • dacă headers e la zi, dar blocks nu avansează, nodul nu poate descărca sau valida: resurse, corupere sau un bloc respins;
  • initialblockdownload și verificationprogress arată dacă e încă în sincronizarea inițială;
  • rețeaua: getconnectioncount, getpeerinfo, getnetworkinfo. Zero conexiuni înseamnă firewall, DNS, port blocat sau networkactive dezactivat. Vecini care nu trimit nimic pot indica o izolare;
  • jurnalul: debug.log din directorul de date. Mesaje despre spațiu pe disc, erori de bază de date, „block rejected” sau blocuri invalide;
  • resurse: spațiu liber pe disc (lanțul complet ocupă sute de GB; un nod pruned mult mai puțin), memorie, I/O. Un dbcache mic face validarea lentă;
  • ceasul sistemului: un ceas mult decalat poate face nodul să respingă blocuri ca fiind „din viitor”;
  • versiunea: un nod foarte vechi poate să nu urmeze regulile actuale.

Soluții după cauză:

  • rețea: deschizi portul 8333 sau adaugi manual vecini cu addnode;
  • performanță: crești dbcache, muți datele pe SSD;
  • corupere: repornești cu -reindex-chainstate sau -reindex, care durează mult, așa că anunți dinainte;
  • dacă nodul servește aplicații, le comuți temporar pe un nod de rezervă.

Raportul final: cauza, ce ai schimbat și ce monitorizare adaugi (alertă când diferența dintre blocuri și antete depășește un prag).

Ce urmărește intervievatorul: Situație de operațiuni pentru roluri de infrastructură. Verifică dacă știi să folosești comenzile reale și să separi problemele de rețea de cele de validare.

100 Senior

Un consorțiu de firme de logistică vrea un blockchain privat pentru trasabilitatea mărfurilor. Ești arhitectul tehnic. Ce întrebări pui și ce riscuri identifici?

Răspuns scurt: Clarifici cine scrie și validează, cum se guvernează rețeaua, ce date sunt confidențiale și cum ajung datele fizice pe lanț. Riscul principal: lanțul garantează că datele n-au fost modificate după înregistrare, nu că au fost corecte la introducere.

Un model de răspuns pe teme:

  • participanți și încredere: câte firme, cine operează noduri, cine validează blocuri. Pentru un grup cunoscut se potrivește un consens BFT sau PoA (de exemplu Hyperledger Fabric, Hyperledger Besu cu QBFT). Dacă o singură firmă controlează majoritatea validatorilor, ceilalți nu câștigă mare lucru;
  • guvernanță: cum intră și ies membri, cine aprobă actualizările de software, ce se întâmplă la un conflict între parteneri, cine plătește infrastructura. Acestea se decid în contracte, nu în cod;
  • confidențialitate: concurenții nu vor să-și vadă reciproc volumele și prețurile. Soluții: canale sau colecții private (Fabric), date criptate off-chain cu doar hash-ul pe lanț, sau dovezi zero-knowledge pentru afirmații limitate;
  • problema oracolului fizic: cine scrie că un container a ajuns? Un angajat, un senzor, un scanner. Dacă intrarea e falsă, blockchain-ul păstrează pentru totdeauna o minciună. Contează identitatea semnatarului, dispozitivele securizate și reconcilierea cu documente;
  • integrare: sistemele ERP existente, standarde de date (de exemplu GS1 pentru identificarea produselor), volum și latență;
  • alternative: o bază de date comună operată de o terță parte neutră, cu jurnal de audit, poate fi suficientă. Merită comparată deschis.

Riscuri de proiect: adopție redusă dacă un participant mare nu vede beneficiu, costuri de operare pentru fiecare nod, tehnologie aleasă înaintea problemei.

Recomandarea: un pilot mic, cu un singur flux de date și indicatori clari de succes, înainte de o rețea completă.

Ce urmărește intervievatorul: Întrebare de arhitectură pentru roluri senior sau de consultanță. Verifică dacă privești proiectul complet: tehnologie, guvernanță, date și oameni, nu doar alegerea platformei.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Blockchain, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Blockchain scriind cod, nu doar citind

Curs Blockchain și criptomonede: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.