...
Pregătire interviuri

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

Întrebările care apar des la interviurile de Blockchain Developer, 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.

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 Developer cu răspunsuri

Procesul de interviu pentru un Blockchain Developer seamănă la început cu cel pentru orice rol de programator: o discuție inițială cu HR sau cu un recrutor, apoi unul sau mai multe interviuri tehnice. Diferența apare la partea tehnică: pe lângă întrebări de programare generală (JavaScript, Python, Git), vei primi întrebări despre cum funcționează un blockchain, despre EVM și gas, despre Solidity și, aproape sigur, despre securitate. Multe echipe dau și o temă practică: un smart contract mic, cu teste, sau citirea unui contract în care trebuie să găsești vulnerabilități.

La nivel de junior se urmărește să înțelegi conceptele de bază fără să le recitești pe de rost: ce garantează o semnătură, de ce costă scrierea în storage, cum arată un token ERC-20, ce este reentrancy și cum o previi. La mid se așteaptă experiență reală: teste cu Hardhat sau Foundry, deploy pe testnet, integrare cu ethers.js, optimizare de gas și un ochi format pentru capcanele de securitate. La senior discuția se mută spre arhitectură, contracte upgradeable, audit, administrare și gestionarea incidentelor.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Scrie și rulează exemplele de cod într-un proiect local, pentru că la interviu contează să poți explica ce ai făcut cu mâna ta. Pagina este despre dezvoltare software, nu despre investiții: nu conține și nu oferă sfaturi financiare.

Fundamente blockchain și consens

1 Junior

Ce este un blockchain și ce problemă rezolvă?

Răspuns scurt: Un blockchain este un registru distribuit, replicat pe multe noduri, în care datele sunt grupate în blocuri legate criptografic. Rezolvă problema acordului asupra unei stări comune între participanți care nu au încredere unii în alții, fără o autoritate centrală.

Gândește-te la o bază de date de tip append-only (doar adaugi, nu modifici) pe care o țin în copie mii de calculatoare independente. Fiecare bloc conține un set de tranzacții și hash-ul blocului anterior, deci dacă cineva modifică o tranzacție veche, se schimbă hash-ul acelui bloc și se rupe legătura cu toate blocurile de după. Nodurile oneste ar respinge imediat varianta falsificată.

Problema de fond este double spending: într-un sistem digital, o monedă este doar un șir de biți, deci cineva ar putea „cheltui” același ban de două ori. Băncile rezolvă asta printr-un registru central. Un blockchain o rezolvă printr-un mecanism de consens (Proof of Work, Proof of Stake), prin care rețeaua cade de acord asupra ordinii tranzacțiilor.

Proprietățile utile pentru un developer:

  • transparență: oricine poate verifica istoricul;
  • rezistență la cenzură și la modificări retroactive;
  • programabilitate: pe Ethereum poți rula cod (smart contracts) a cărui execuție este verificată de toată rețeaua.

Costul acestor garanții este performanța: scrierea datelor este lentă și scumpă comparativ cu o bază de date clasică. De aceea, un răspuns matur menționează și când NU ai nevoie de blockchain: dacă există deja o entitate de încredere care poate ține registrul, o bază de date obișnuită este aproape întotdeauna mai bună.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi problema reală (acord fără încredere, double spending), nu doar definiția din dicționar. Greșeala tipică: a prezenta blockchain-ul ca soluție universală, fără a menționa compromisurile.

2 Junior

Ce conține un bloc și cum sunt legate blocurile între ele?

Răspuns scurt: Un bloc are un header (hash-ul blocului părinte, rădăcini Merkle sau Merkle-Patricia, timestamp, număr, alte câmpuri ale protocolului) și un corp cu lista de tranzacții. Legătura se face prin hash-ul părintelui inclus în header.

Pe Ethereum, header-ul unui bloc include printre altele: parentHash, stateRoot (rădăcina arborelui cu starea tuturor conturilor), transactionsRoot, receiptsRoot, number, timestamp, gasLimit, gasUsed și baseFeePerGas (din EIP-1559). Corpul conține tranzacțiile, iar după The Merge blocul de execuție este împachetat într-un bloc al lanțului de consens (Beacon Chain).

Hash-ul unui bloc se calculează din header. Pentru că header-ul conține parentHash, fiecare bloc „semnează” practic tot istoricul de dinaintea lui. Dacă modifici o tranzacție din blocul 100, se schimbă transactionsRoot al blocului 100, deci hash-ul lui, deci parentHash din blocul 101 nu mai corespunde, și așa mai departe până la capătul lanțului.

Rădăcinile Merkle sunt importante practic: un client ușor poate verifica faptul că o tranzacție sau o valoare din state face parte dintr-un bloc folosind doar header-ul și o dovadă scurtă (Merkle proof), fără să descarce tot blocul.

Pe Bitcoin, header-ul este mai simplu: versiune, hash-ul anterior, rădăcina Merkle a tranzacțiilor, timestamp, dificultate (bits) și nonce-ul căutat de mineri.

Ce urmărește intervievatorul: Se verifică dacă știi de unde vine imutabilitatea (lanțul de hash-uri) și ce rol au rădăcinile din header. Mulți candidați spun doar „blocul conține tranzacții” și nu pot explica de ce o modificare retroactivă este detectabilă.

3 Junior

Care este diferența dintre Proof of Work și Proof of Stake?

Răspuns scurt: În Proof of Work, dreptul de a produce un bloc se câștigă cheltuind putere de calcul pentru un puzzle criptografic. În Proof of Stake, validatorii blochează monede ca garanție și sunt aleși să propună sau să atesteze blocuri, putând pierde garanția dacă trișează.

În Proof of Work (Bitcoin, Ethereum înainte de septembrie 2022), minerii modifică un nonce din header până când hash-ul blocului este sub o țintă de dificultate. Găsirea soluției cere multe încercări, dar verificarea ei este instantanee. Securitatea vine din cost: ca să rescrii istoria, ai nevoie de mai multă putere de calcul decât restul rețelei. Regula de alegere a lanțului este, simplificat, „lanțul cu cea mai multă muncă acumulată”.

În Proof of Stake (Ethereum după The Merge), un validator depune 32 ETH ca garanție. Protocolul alege pseudoaleator un propunător pentru fiecare slot, iar comitete de validatori atestă blocurile. Dacă un validator semnează două blocuri contradictorii pentru același slot sau voturi contradictorii, este penalizat prin slashing (își pierde o parte din garanție și este scos din set).

Diferențe practice:

  • consum de energie: PoS este mult mai eficient, pentru că nu se bazează pe calcul brut;
  • finalitate: Ethereum PoS are finalitate explicită (după aproximativ două epoci), pe când în PoW finalitatea este doar probabilistă;
  • tipul de atac: în PoW atacatorul are nevoie de hardware, în PoS de o parte mare din stake, care poate fi distrusă prin slashing.

Pentru un developer de smart contracts, consensul contează mai ales la numărul de confirmări pe care îl aștepți și la ce poate influența propunătorul unui bloc (ordinea tranzacțiilor, timestamp-ul).

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi de unde vine securitatea în fiecare model, nu doar „PoW consumă energie, PoS nu”. Greșeala tipică: a nu ști că Ethereum a trecut la PoS sau ce este slashing.

4 Junior

Ce înseamnă finalitatea unei tranzacții și de ce contează pentru o aplicație?

Răspuns scurt: Finalitatea înseamnă momentul din care o tranzacție nu mai poate fi scoasă din istoric. Poate fi probabilistă (Bitcoin, cu tot mai multe confirmări) sau economică și explicită (Ethereum PoS, după ce checkpoint-ul este finalizat).

Când o tranzacție apare într-un bloc, nu este încă „definitivă”. Lanțul se poate reorganiza dacă rețeaua alege o altă ramură, iar blocul tău poate dispărea. Aplicațiile tratează asta în funcție de miză.

Pe Bitcoin, finalitatea este probabilistă: fiecare bloc nou adăugat peste al tău face exponențial mai scumpă rescrierea lui. De aceea se vorbește de „6 confirmări” ca regulă practică pentru sume mari, dar nu există un punct matematic de la care este imposibilă rescrierea.

Pe Ethereum PoS, timpul este împărțit în sloturi de 12 secunde și epoci de 32 de sloturi. Validatorii votează checkpoint-uri, iar când un checkpoint primește voturi de la cel puțin două treimi din stake în două epoci consecutive, devine finalized. Ca să-l anulezi, ar trebui ca cel puțin o treime din stake să fie distrusă prin slashing, ceea ce face atacul extrem de scump. Prin RPC poți cere explicit blocul finalized sau safe, nu doar latest.

Consecințe practice:

  • un exchange sau un bridge creditează depozitele abia după finalitate;
  • un indexer trebuie să poată reveni asupra datelor din blocuri ne-finalizate;
  • un UI poate afișa „confirmată” după includere, dar logica de business critică așteaptă finalized.

Pe rețele Layer 2 apare încă un nivel: tranzacția este acceptată de sequencer rapid, dar finalitatea reală depinde de publicarea și confirmarea datelor pe Layer 1.

Ce urmărește intervievatorul: Se verifică dacă știi că „inclus într-un bloc” nu înseamnă „definitiv”. Candidații confundă des confirmarea în UI cu finalitatea și nu știu de tag-urile safe și finalized.

5 Junior

Care este diferența dintre un blockchain public, unul privat și unul de tip consorțiu?

Răspuns scurt: Un blockchain public (Ethereum, Bitcoin) este deschis oricui să citească, să trimită tranzacții și să participe la consens. Unul privat sau de consorțiu (de exemplu Hyperledger Fabric) limitează cine poate valida și uneori cine poate citi, în schimbul performanței și controlului.

Diferența principală este cine are voie să participe la consens.

  • Public, permissionless: oricine poate rula un nod, poate deveni validator dacă îndeplinește condițiile (de exemplu stake) și poate trimite tranzacții. Securitatea vine din stimulente economice. Exemple: Bitcoin, Ethereum și rețelele Layer 2 construite peste el.
  • Privat: o singură organizație controlează nodurile. Practic, este o bază de date distribuită cu istoric verificabil. Utilitatea este limitată, pentru că încrederea rămâne centralizată.
  • Consorțiu (permissioned): mai multe organizații cunoscute își împart validarea, de exemplu un grup de firme care vor un registru comun. Se folosesc algoritmi de consens de tip BFT sau Raft, mai rapizi, pentru că participanții sunt identificați.

Compromisuri:

  • rețelele permissioned au debit mai mare și costuri previzibile, plus confidențialitate;
  • pierd însă rezistența la cenzură și neutralitatea care fac utile rețelele publice;
  • ecosistemul de unelte (Solidity, EVM, ethers.js) este cel mai bogat pe rețelele publice compatibile EVM.

La interviu e bine să arăți că alegerea depinde de cerințe: dacă participanții se încred deja unul în altul, un sistem permissioned sau chiar o bază de date clasică poate fi soluția corectă. Dacă vrei ca oricine să poată verifica și folosi sistemul fără acordul unui operator, ai nevoie de o rețea publică.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți argumenta alegerea tipului de rețea în funcție de modelul de încredere. Greșeala tipică: a spune că blockchain-urile private sunt „la fel, doar mai rapide”.

6 Junior

Ce este un nod și ce tipuri de noduri există pe Ethereum?

Răspuns scurt: Un nod este un program care păstrează o copie a lanțului, validează blocurile și tranzacțiile și le propagă. Pe Ethereum există full nodes, archive nodes și light clients, iar fiecare nod rulează un client de execuție și unul de consens.

Un nod Ethereum are azi două componente:

  • clientul de execuție (de exemplu Geth, Nethermind, Besu, Erigon, Reth): rulează EVM, ține starea și mempool-ul, expune JSON-RPC;
  • clientul de consens (de exemplu Lighthouse, Prysm, Teku, Nimbus, Lodestar): urmărește Beacon Chain și regulile Proof of Stake.

Tipuri, după cât păstrează:

  • Full node: validează tot, păstrează starea curentă și un istoric recent al stărilor. Poate răspunde la întrebări despre prezent, dar nu neapărat despre starea de acum un an.
  • Archive node: păstrează toate stările istorice. Necesar dacă vrei să rulezi eth_call sau să citești un sold la un bloc vechi. Ocupă mult mai mult spațiu.
  • Light client: păstrează doar header-e și cere dovezi de la alte noduri. Potrivit pentru dispozitive cu resurse reduse.

Validatorul este un rol suplimentar: un client de consens cu chei de validare și stake, care propune și atestă blocuri.

Pentru un developer, contează practic două lucruri. Primul: aplicația ta vorbește cu un nod prin JSON-RPC, fie propriu, fie printr-un furnizor de RPC. Al doilea: unele apeluri (istoric de state, debug_traceTransaction) funcționează doar pe noduri archive sau cu API-uri de debug activate, deci trebuie să alegi furnizorul în funcție de ce interogări faci.

Ce urmărește intervievatorul: Se verifică dacă știi ce se află în spatele unui URL de RPC și de ce unele interogări istorice eșuează. Mulți juniori nu știu de separarea execuție/consens după The Merge.

7 Junior

Care este diferența dintre modelul UTXO (Bitcoin) și modelul pe conturi (Ethereum)?

Răspuns scurt: În UTXO, soldul tău este suma ieșirilor necheltuite pe care le poți debloca, iar o tranzacție consumă ieșiri și creează altele noi. În modelul pe conturi, starea globală ține direct un sold și un nonce pentru fiecare adresă, plus cod și storage pentru contracte.

În UTXO (Unspent Transaction Output), nu există „contul lui Andrei cu 1,5 BTC”. Există ieșiri ale unor tranzacții anterioare, fiecare blocată cu o condiție (de obicei o semnătură). Când plătești, aduni ieșiri care acoperă suma, le consumi integral și creezi ieșiri noi: una pentru destinatar și una de „rest” înapoi către tine. Soldul afișat de wallet este suma UTXO-urilor tale.

Avantaje UTXO: tranzacțiile independente se pot valida în paralel, iar protecția la replay este naturală, pentru că o ieșire se poate cheltui o singură dată.

În modelul pe conturi (Ethereum), starea este o mapare adresă -> {nonce, balance, codeHash, storageRoot}. O tranzacție scade soldul expeditorului și îl crește pe al destinatarului. Protecția la replay vine din nonce: fiecare tranzacție a unui cont are un număr de ordine care trebuie să fie exact următorul.

Avantaje cont: modelul este intuitiv pentru programare, iar smart contractele pot ține stare complexă (mapări, structuri) și pot interacționa direct între ele.

Pentru interviu e util un exemplu: pe Ethereum, un sold de token ERC-20 nu este nici măcar în contul tău, ci într-o mapare balances[adresa] din storage-ul contractului tokenului. Asta explică de ce un wallet trebuie să „știe” de un token ca să-l afișeze.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi cum se reprezintă starea și cum se previne replay-ul în fiecare model. Greșeala tipică: a crede că tokenurile ERC-20 se țin în contul utilizatorului, nu în storage-ul contractului.

8 Junior

Ce este un fork și care este diferența dintre soft fork și hard fork?

Răspuns scurt: Un fork este o divergență a lanțului sau a regulilor. Un soft fork restrânge regulile și rămâne compatibil cu nodurile vechi, iar un hard fork schimbă regulile într-un mod pe care nodurile vechi nu îl acceptă, deci toate nodurile trebuie actualizate.

Cuvântul „fork” are două sensuri, și e bine să le separi.

Primul: o ramificare temporară a lanțului, când doi producători publică blocuri aproape simultan. Rețeaua converge pe o ramură, iar cealaltă este abandonată (reorganizare). Este un eveniment normal, nu o schimbare de reguli.

Al doilea: o schimbare de protocol.

  • Soft fork: noile reguli sunt mai stricte. Blocurile produse după regulile noi sunt valide și pentru nodurile vechi, deci acestea continuă să funcționeze, chiar dacă nu înțeleg toate funcționalitățile noi. Exemplu: SegWit pe Bitcoin.
  • Hard fork: noile reguli acceptă lucruri pe care regulile vechi le-ar respinge (sau invers). Nodurile neactualizate rămân pe un lanț separat. Pe Ethereum, actualizările de rețea (London cu EIP-1559, The Merge, Shanghai, Cancun-Deneb, Pectra) sunt hard fork-uri planificate, coordonate cu toate echipele de clienți.

Când comunitatea nu este de acord, un hard fork poate produce două lanțuri care trăiesc în paralel, cum s-a întâmplat cu Ethereum și Ethereum Classic după incidentul The DAO din 2016.

Pentru un developer de contracte, hard fork-urile sunt relevante direct: pot schimba costurile opcode-urilor (EIP-2929), comportamentul unor instrucțiuni (SELFDESTRUCT după EIP-6780) sau pot adăuga opcode-uri noi (PUSH0, TSTORE). De aceea setezi versiunea EVM țintă în compilator în funcție de rețeaua pe care faci deploy.

Ce urmărește intervievatorul: Se verifică dacă știi de ce actualizările de rețea te afectează ca developer (costuri de gas, opcode-uri, versiunea EVM a compilatorului). Candidații uită des sensul de reorganizare temporară.

9 Mid

Ce este trilema blockchain și cum o abordează soluțiile Layer 2, de exemplu rollup-urile?

Răspuns scurt: Trilema spune că e greu să obții simultan descentralizare, securitate și scalabilitate pe un singur strat. Rollup-urile execută tranzacțiile în afara Layer 1, dar publică datele și dovezile pe Layer 1, moștenind astfel securitatea acestuia.

Dacă vrei ca oricine să poată rula un nod (descentralizare), blocurile trebuie să rămână mici, deci debitul este limitat. Dacă mărești blocurile, crește costul hardware și scade numărul de participanți. Aceasta este, simplificat, trilema.

Abordarea Ethereum este „rollup-centric”: Layer 1 rămâne strat de securitate și disponibilitate a datelor, iar execuția se mută pe Layer 2.

Două familii de rollup-uri:

  • Optimistic rollups (de exemplu Arbitrum, Optimism, Base): presupun că loturile de tranzacții sunt corecte. Oricine poate contesta o stare greșită printr-o dovadă de fraudă într-o fereastră de timp. De aceea retragerea nativă către Layer 1 durează de obicei câteva zile.
  • ZK rollups (de exemplu zkSync Era, Starknet, Scroll, Linea): publică o dovadă criptografică de validitate pentru fiecare lot. Layer 1 verifică dovada, deci starea este corectă prin construcție, iar retragerile nu au nevoie de fereastra de contestare.

Upgrade-ul Dencun (martie 2024) a introdus prin EIP-4844 tranzacțiile cu blobs, un spațiu de date mai ieftin destinat rollup-urilor, ceea ce a redus mult costurile pe Layer 2.

De reținut pentru interviu: multe Layer 2 au încă un sequencer centralizat și chei de upgrade, deci securitatea practică depinde și de cât de matur este acel rollup. Ca developer, trebuie să știi și diferențele de comportament (de exemplu block.number sau prețul gas-ului) față de Layer 1.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de unde vine securitatea unui Layer 2 și diferența optimistic vs ZK. Greșeala tipică: a crede că orice „chain rapid compatibil EVM” este un rollup.

10 Mid

Ce este problema generalilor bizantini și ce înseamnă toleranța la erori bizantine (BFT)?

Răspuns scurt: Problema generalilor bizantini descrie cum pot cădea de acord participanți dintr-un sistem distribuit când unii pot minți sau se pot comporta arbitrar. Un sistem BFT ajunge la consens corect atât timp cât participanții rău intenționați sunt sub un prag, de obicei sub o treime.

Într-un sistem distribuit obișnuit, te aștepți ca un nod să cadă (crash fault). Într-o rețea deschisă, un nod poate face mai rău: poate trimite mesaje contradictorii către noduri diferite. Asta este o eroare bizantină.

Rezultatul clasic pentru protocoalele BFT cu participanți cunoscuți (de exemplu PBFT sau Tendermint) este că, în condiții de rețea parțial sincronă, poți tolera până la f noduri bizantine dintr-un total de 3f + 1. Cu alte cuvinte, ai nevoie de mai mult de două treimi de participanți onești. De aici vine pragul de două treimi din stake folosit și la finalizarea checkpoint-urilor în Ethereum.

Nakamoto consensus (Bitcoin) abordează problema altfel: nu știe câți participanți există, așa că folosește costul (Proof of Work) ca să limiteze influența și oferă doar finalitate probabilistă.

Concepte legate pe care e bine să le poți menționa:

  • safety (nu se finalizează două istorii contradictorii) vs liveness (sistemul continuă să producă blocuri);
  • teorema CAP și rezultatul FLP: nu poți garanta ambele în orice condiții de rețea, deci protocoalele aleg compromisuri;
  • Ethereum combină o regulă de alegere a lanțului orientată spre liveness cu un mecanism de finalitate orientat spre safety.

La interviu, un exemplu clar ajută: dacă un validator semnează două blocuri diferite pentru același slot, comportamentul lui este bizantin, iar protocolul îl detectează și îl penalizează.

Ce urmărește intervievatorul: Se verifică dacă ai fundamente de sisteme distribuite și înțelegi de unde vine pragul de două treimi. Candidații recită povestea generalilor fără a o lega de safety, liveness și slashing.

11 Mid

Ce este o reorganizare de lanț (reorg) și cum o tratezi într-un backend care urmărește tranzacții?

Răspuns scurt: Un reorg are loc când rețeaua abandonează unul sau mai multe blocuri recente în favoarea unei alte ramuri. Un backend trebuie să aștepte confirmări sau finalitate înainte de acțiuni ireversibile și să poată anula datele indexate din blocurile eliminate.

Când doi producători de blocuri publică aproape simultan, sau când nodurile văd mesajele în ordine diferită, poate exista temporar mai mult de un vârf al lanțului. Regula de alegere a lanțului decide care rămâne, iar blocurile de pe ramura pierdută sunt eliminate. Tranzacțiile din ele se întorc de obicei în mempool și pot fi incluse mai târziu, eventual în altă ordine sau deloc.

Ce faci concret într-un serviciu care procesează depozite sau events:

  • stochezi pentru fiecare event blockNumber, blockHash și logIndex;
  • la fiecare bloc nou verifici că parentHash corespunde cu hash-ul blocului salvat anterior; dacă nu, ai detectat un reorg și revii înapoi până la ultimul bloc comun;
  • marchezi datele ca „pending” până la un număr de confirmări sau până când blocul devine finalized;
  • faci procesarea idempotentă, ca reprocesarea aceluiași event să nu dubleze o creditare.
JavaScript
const finalized = await provider.getBlock("finalized");
// procesează ireversibil doar evenimentele cu blockNumber <= finalized.number

Pentru UI poți afișa starea imediat după includere, cu mențiunea că se confirmă. Pentru bani, creditări sau trimiteri către alt lanț, aștepți finalitatea.

Pe Layer 2 contează și sequencer-ul: reorg-urile sunt rare, dar finalitatea reală depinde de Layer 1. Un răspuns bun arată că ai gândit cazul de eșec, nu doar drumul fericit.

Ce urmărește intervievatorul: Intervievatorul caută experiență practică cu indexare și idempotență. Greșeala tipică: a procesa event-urile o singură dată, la primul bloc în care apar, fără nicio verificare ulterioară.

12 Senior

Explică cum funcționează consensul Ethereum după The Merge: sloturi, epoci, LMD-GHOST, Casper FFG și slashing.

Răspuns scurt: Ethereum folosește Gasper: LMD-GHOST alege vârful lanțului pe baza celor mai recente atestări ponderate cu stake, iar Casper FFG finalizează checkpoint-uri la granița epocilor când primesc două treimi din stake. Comportamentul contradictoriu este pedepsit prin slashing.

Timpul este împărțit în sloturi de 12 secunde și epoci de 32 de sloturi. În fiecare slot, un validator ales pseudoaleator (folosind RANDAO) propune un bloc, iar un comitet de validatori îl atestă. Fiecare validator atestă o dată pe epocă.

O atestare conține două voturi:

  • un vot pentru capul lanțului, folosit de LMD-GHOST (Latest Message Driven Greedy Heaviest Observed Sub-Tree): pornind de la ultimul checkpoint justificat, la fiecare bifurcație alegi subarborele cu cel mai mult stake în ultimele atestări ale validatorilor;
  • un vot de tip sursă-țintă între checkpoint-uri (primul bloc al epocii), folosit de Casper FFG. Un checkpoint cu voturi de la cel puțin două treimi din stake devine *justified*; când checkpoint-ul următor este justificat pornind de la el, primul devine *finalized*.

Slashing pedepsește comportamentul dovedibil contradictoriu: două propuneri diferite pentru același slot, două atestări cu aceeași țintă, sau voturi care se „înconjoară” (surround vote). Validatorul pierde o parte din stake, iar penalizarea crește dacă mulți validatori sunt penalizați în aceeași perioadă. Pe lângă asta, există penalizări mai mici pentru inactivitate și un mecanism de *inactivity leak* când rețeaua nu mai poate finaliza.

Consecințe pentru aplicații: finalitatea apare de obicei după aproximativ două epoci, propunătorul unui bloc controlează ordinea tranzacțiilor din bloc, iar block.prevrandao oferă o sursă de aleatoriu influențabilă de propunător, deci nepotrivită pentru loterii cu miză.

Ce urmărește intervievatorul: La nivel senior se verifică dacă poți lega detaliile protocolului de consecințele pentru aplicații (finalitate, MEV, aleatoriu). Greșeala tipică: amestecarea rolurilor celor două componente ale Gasper.

Criptografie: hashing, chei și semnături

13 Junior

Ce este o funcție hash criptografică și ce proprietăți trebuie să aibă? Ce hash folosește Ethereum?

Răspuns scurt: O funcție hash criptografică transformă orice input într-un rezumat de lungime fixă, determinist, greu de inversat și practic fără coliziuni. Ethereum folosește Keccak-256 (keccak256 în Solidity), care diferă de SHA3-256 standardizat de NIST prin padding.

Proprietățile cerute:

  • determinism: același input dă mereu același output;
  • rezistență la preimagine: dintr-un hash nu poți găsi un input care îl produce;
  • rezistență la a doua preimagine: dat fiind un input, nu poți găsi altul cu același hash;
  • rezistență la coliziuni: nu poți găsi două input-uri oarecare cu același hash;
  • efect de avalanșă: o modificare de un bit schimbă complet rezultatul.

Bitcoin folosește SHA-256 (de două ori pentru header-e). Ethereum folosește Keccak-256, varianta originală câștigătoare a competiției SHA-3, înainte ca NIST să schimbe padding-ul. De aceea keccak256("abc") nu este egal cu rezultatul SHA3-256 din multe biblioteci standard. În Solidity există și sha256, ca precompilat, dar aproape tot ce ține de protocol și de ABI folosește keccak256.

Unde apare în munca de zi cu zi:

  • selectorul unei funcții: primii 4 octeți din keccak256("transfer(address,uint256)");
  • topicul unui event: keccak256("Transfer(address,address,uint256)");
  • sloturile din storage pentru mapări;
  • adresele derivate din chei publice.
SOLIDITY
bytes32 h = keccak256(abi.encode(user, amount));

Atenție la abi.encodePacked cu mai multe tipuri dinamice: encodePacked("ab", "c") și encodePacked("a", "bc") produc aceiași octeți, deci același hash.

Ce urmărește intervievatorul: Se verifică dacă știi proprietățile și unde apare hash-ul concret în Ethereum. Greșelile tipice: a spune că Ethereum folosește SHA-256 sau a nu cunoaște problema coliziunilor cu abi.encodePacked.

14 Junior

Cum se ajunge de la o cheie privată la o adresă Ethereum?

Răspuns scurt: Cheia privată este un număr aleator de 256 de biți. Din ea se calculează cheia publică pe curba eliptică secp256k1, iar adresa este formată din ultimii 20 de octeți ai hash-ului Keccak-256 al cheii publice necomprimate.

Pașii:

  • Cheia privată: un număr de 32 de octeți ales aleator, mai mic decât ordinul curbei secp256k1. Securitatea întregului cont depinde de faptul că acest număr este generat cu un generator criptografic sigur și nu este expus niciodată.
  • Cheia publică: punctul de pe curbă obținut prin înmulțirea scalară a punctului generator G cu cheia privată. Calculul este rapid într-o direcție, dar inversarea lui (problema logaritmului discret pe curbe eliptice) este considerată imposibilă practic. Forma necomprimată are 64 de octeți (coordonatele x și y), plus un prefix de un octet care nu intră în hash.
  • Adresa: keccak256(cheiePublica64) și păstrezi ultimii 20 de octeți. Reprezentarea hex are 40 de caractere, cu prefixul 0x.

EIP-55 adaugă un checksum prin majuscule: anumite litere hex sunt scrise mare în funcție de hash-ul adresei. Un wallet poate astfel detecta multe greșeli de tastare.

JavaScript
import { Wallet } from "ethers"; // ethers v6
const w = Wallet.createRandom();
console.log(w.address); // adresa cu checksum EIP-55

Observații utile la interviu:

  • adresa nu dezvăluie cheia publică până când contul nu semnează o tranzacție;
  • un contract nu are cheie privată; adresa lui este derivată din adresa creatorului și nonce sau salt;
  • cine are cheia privată controlează complet contul, deci nu o pui niciodată în cod, în Git sau în loguri.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi lanțul criptografic din spatele unui cont. Greșeala tipică: a confunda adresa cu cheia publică sau a crede că adresa se poate „inversa”.

15 Junior

Ce este o semnătură digitală și ce garantează într-o tranzacție blockchain?

Răspuns scurt: O semnătură digitală este o valoare calculată din mesaj și cheia privată, pe care oricine o poate verifica cu cheia publică. Garantează autenticitatea (doar deținătorul cheii a putut semna), integritatea (mesajul nu a fost modificat) și non-repudierea.

Ethereum și Bitcoin folosesc ECDSA pe curba secp256k1 (Bitcoin folosește și Schnorr din Taproot). O semnătură ECDSA Ethereum are trei componente: r, s (câte 32 de octeți) și v, un octet care ajută la recuperarea cheii publice.

Când trimiți o tranzacție, wallet-ul serializează câmpurile ei (nonce, destinatar, valoare, date, gas, chainId) și le semnează. Nodurile verifică semnătura și recuperează din ea adresa expeditorului. De aceea tranzacțiile Ethereum nu conțin câmpul from: este dedus criptografic.

Ce garantează:

  • doar cine deține cheia privată putea produce semnătura;
  • orice modificare a unui câmp, de exemplu a sumei, invalidează semnătura;
  • semnătura este legată de chainId (EIP-155), deci nu poate fi refolosită pe alt lanț.

Ce NU garantează:

  • confidențialitate: datele tranzacției sunt publice;
  • că utilizatorul a înțeles ce semnează. Multe fraude se bazează pe semnarea unor mesaje sau aprobări cu aspect inofensiv.

Un detaliu important: ECDSA are nevoie de un număr aleator k unic la fiecare semnătură. Dacă același k este folosit de două ori cu aceeași cheie, cheia privată poate fi calculată. Bibliotecile moderne folosesc k determinist (RFC 6979), de aceea nu îți scrii niciodată propria implementare de semnături.

Ce urmărește intervievatorul: Se verifică dacă știi exact ce oferă semnătura și ce nu. Candidații spun des că semnătura „criptează” tranzacția, ceea ce este greșit.

16 Junior

Ce este un Merkle tree și unde se folosește în blockchain?

Răspuns scurt: Un Merkle tree este un arbore binar în care fiecare frunză este hash-ul unui element, iar fiecare nod intern este hash-ul copiilor săi. Rădăcina rezumă tot setul, iar apartenența unui element se demonstrează cu o dovadă de dimensiune logaritmică.

Construcția: hash-uiești fiecare element (frunzele), apoi combini hash-urile două câte două și hash-uiești din nou, până rămâne un singur hash: rădăcina Merkle. Dacă modifici orice element, se schimbă rădăcina.

Avantajul cheie este dovada de apartenență: ca să arăți că elementul X este în set, nu trebuie să trimiți tot setul, ci doar hash-urile „surori” de pe drumul de la frunză la rădăcină. Pentru un milion de elemente, asta înseamnă în jur de 20 de hash-uri, pentru că 2 la puterea 20 depășește un milion.

Unde apare:

  • Bitcoin: rădăcina Merkle a tranzacțiilor din header permite clienților ușori (SPV) să verifice că o tranzacție este într-un bloc;
  • Ethereum folosește Merkle-Patricia Tries pentru stare, tranzacții și receipts, o structură care permite și căutare după cheie;
  • smart contracts: allowlist-uri și airdrop-uri. În loc să salvezi mii de adrese în storage (scump), salvezi doar rădăcina, iar fiecare utilizator trimite dovada lui.
SOLIDITY
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

function claim(uint256 amount, bytes32[] calldata proof) external {
    bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender, amount))));
    require(MerkleProof.verify(proof, root, leaf), "proof invalid");
    // marchează revendicarea și transferă
}

Arborele se construiește off-chain, iar contractul doar verifică.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi de ce dovada este mică și cum se folosește practic în contracte. Greșeala tipică: a stoca liste întregi on-chain în loc de o rădăcină.

17 Junior

Ce este o seed phrase și cum funcționează un wallet HD?

Răspuns scurt: O seed phrase (BIP-39) este o listă de 12 sau 24 de cuvinte din care se derivă un seed. Un wallet HD (BIP-32, cu căile din BIP-44) generează din acel seed un arbore determinist de chei, deci toate conturile se pot recupera din aceeași frază.

Ca să nu salvezi separat fiecare cheie privată, wallet-urile moderne pornesc de la o singură sursă de entropie.

  • BIP-39: entropia (128 sau 256 de biți) plus un checksum se transformă în cuvinte dintr-o listă standard de 2048 de cuvinte. Fraza, opțional împreună cu o parolă suplimentară, este trecută prin PBKDF2 ca să obții un seed de 512 biți.
  • BIP-32: din seed se obține o cheie master și un „chain code”, din care se pot deriva determinist chei copil, nepoți și așa mai departe.
  • BIP-44: standardizează căile de derivare. Pentru Ethereum, primul cont este de obicei m/44'/60'/0'/0/0, următoarele schimbă ultimul index.

Consecințe practice:

  • cine are seed phrase-ul are toate conturile derivate, nu doar unul;
  • poți importa aceeași frază în alt wallet compatibil și obții aceleași adrese, cu condiția să folosească aceeași cale;
  • în dezvoltare, Hardhat și Anvil pornesc cu o frază de test publică, ale cărei conturi nu trebuie folosite niciodată pe mainnet.
JavaScript
import { HDNodeWallet } from "ethers"; // ethers v6
const w = HDNodeWallet.fromPhrase(process.env.TEST_MNEMONIC, undefined, "m/44'/60'/0'/0/1");

La interviu, menționează și partea de securitate: fraza nu se ține în cod, în chat-uri sau în cloud necriptat, iar pentru sume sau roluri importante se folosesc hardware wallets sau multisig.

Ce urmărește intervievatorul: Se verifică dacă înțelegi relația frază - seed - chei și riscul real. Greșeala tipică: a crede că fiecare cont are o frază separată sau că fraza „este” cheia privată a unui singur cont.

18 Mid

Cum verifici într-un smart contract că un mesaj a fost semnat de o anumită adresă? Ce sunt EIP-191 și EIP-712?

Răspuns scurt: Recuperezi semnatarul cu ecrecover (sau mai sigur cu biblioteca ECDSA din OpenZeppelin) din hash-ul mesajului și semnătură, apoi compari cu adresa așteptată. EIP-191 definește prefixul pentru mesaje personale, iar EIP-712 definește semnarea de date structurate, lizibile în wallet.

Pentru semnături off-chain (de exemplu un voucher, o aprobare sau o comandă), utilizatorul semnează în wallet, iar contractul verifică.

EIP-191 (personal_sign): wallet-ul adaugă prefixul "\x19Ethereum Signed Message:\n" + lungime înainte de hash. Scopul este ca un mesaj semnat să nu poată fi niciodată interpretat ca o tranzacție validă.

EIP-712: semnezi o structură tipizată, cu un domain separator care include numele aplicației, versiunea, chainId și adresa contractului. Wallet-ul îi afișează utilizatorului câmpurile (destinatar, sumă, termen), nu un hash opac, iar semnătura nu poate fi refolosită pe alt contract sau alt lanț.

SOLIDITY
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";

contract Vouchers is EIP712("Vouchers", "1") {
    bytes32 constant TYPEHASH = keccak256("Voucher(address to,uint256 amount,uint256 nonce)");
    mapping(address => uint256) public nonces;
    address public signer;

    function redeem(uint256 amount, bytes calldata sig) external {
        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(TYPEHASH, msg.sender, amount, nonces[msg.sender]++)));
        require(ECDSA.recover(digest, sig) == signer, "semnatura invalida");
        // ...
    }
}

De ce ECDSA.recover și nu ecrecover direct: ecrecover întoarce address(0) la semnături invalide în loc să dea revert, iar biblioteca respinge și valorile s din jumătatea superioară a curbei, care permit o a doua semnătură validă pentru același mesaj.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să implementezi corect verificarea și de ce există domain separator-ul. Greșeala tipică: folosirea directă a lui ecrecover fără a trata rezultatul address(0).

19 Mid

Ce sunt atacurile de tip replay cu semnături și cum le previi?

Răspuns scurt: Un replay înseamnă refolosirea unei semnături valide de mai multe ori sau în alt context (alt contract, alt lanț). Le previi incluzând în mesajul semnat un nonce, chainId, adresa contractului și un termen de expirare, și marcând semnăturile consumate.

Semnătura dovedește că cineva a aprobat un mesaj, dar nu spune nimic despre de câte ori sau unde poate fi folosit acel mesaj. Dacă un contract acceptă „semnătura lui Admin pentru a plăti 100 de tokenuri lui X”, atacatorul poate trimite aceeași semnătură de zece ori.

Variante de replay:

  • în același contract: lipsește nonce-ul sau marcarea ca folosit;
  • între contracte: același format de mesaj este acceptat de două deploy-uri diferite;
  • între lanțuri: contractul există la aceeași adresă pe mai multe rețele, iar mesajul nu include chainId.

Măsuri:

  • nonce per utilizator, incrementat la fiecare folosire, sau o mapare used[digest] = true;
  • domain separator EIP-712 cu chainId și verifyingContract;
  • câmp deadline, verificat cu block.timestamp;
  • verificarea efectivă că semnatarul este cel așteptat și nu address(0).

Malleability: în ECDSA, pentru o semnătură (r, s) există și (r, n - s) validă pentru același mesaj. Dacă identifici semnăturile consumate după octeții semnăturii, atacatorul poate trimite varianta „oglindită”. De aceea marchezi ca folosit hash-ul mesajului sau nonce-ul, nu semnătura, și folosești o bibliotecă care acceptă doar s din jumătatea inferioară.

La nivel de protocol, EIP-155 a rezolvat problema pentru tranzacțiile obișnuite prin includerea chainId în datele semnate.

Ce urmărește intervievatorul: Se verifică dacă te gândești la contextul în care e valabilă o semnătură. Greșeala tipică: a stoca semnătura ca cheie a mapării de „folosite”, ceea ce lasă loc pentru malleability.

20 Mid

Ce este o schemă commit-reveal și când ai folosi-o într-un contract?

Răspuns scurt: Commit-reveal împarte o acțiune în doi pași: întâi publici doar hash-ul alegerii tale plus un secret (commit), apoi, după o perioadă, dezvălui alegerea și secretul (reveal). Se folosește când informația vizibilă în mempool sau on-chain ar permite altora să profite.

Tot ce trimiți pe un blockchain public este vizibil, inclusiv în mempool, înainte să intre în bloc. La un vot, o licitație cu oferte închise sau un joc de tip piatră-foarfecă-hârtie, cine acționează al doilea are avantaj dacă vede alegerea primului.

Soluția: în faza de commit trimiți keccak256(abi.encode(alegere, salt, msg.sender)). Hash-ul nu dezvăluie alegerea, iar salt-ul aleator împiedică ghicirea prin încercarea tuturor variantelor posibile. Includerea msg.sender împiedică pe altcineva să copieze commit-ul tău. În faza de reveal, trimiți alegerea și salt-ul, iar contractul recalculează hash-ul.

SOLIDITY
mapping(address => bytes32) public commits;

function commit(bytes32 h) external {
    require(block.timestamp < commitEnd, "commit inchis");
    commits[msg.sender] = h;
}

function reveal(uint8 choice, bytes32 salt) external {
    require(block.timestamp >= commitEnd && block.timestamp < revealEnd, "nu e faza de reveal");
    require(keccak256(abi.encode(choice, salt, msg.sender)) == commits[msg.sender], "nu corespunde");
    delete commits[msg.sender];
    // înregistrează alegerea
}

Limitări de menționat: utilizatorul poate refuza să facă reveal dacă vede că pierde, deci de obicei ceri un depozit care se pierde la lipsa reveal-ului. În plus, experiența de utilizare are doi pași și două tranzacții.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să proiectezi în jurul transparenței mempool-ului. Greșeala tipică: commit fără salt sau fără adresa expeditorului, ceea ce face hash-ul ghicibil sau copiabil.

21 Senior

Implementezi un airdrop cu Merkle proof. Ce capcane de securitate trebuie să eviți?

Răspuns scurt: Capcanele principale sunt: frunzele care pot fi confundate cu noduri interne (atac de a doua preimagine), codificarea ambiguă cu encodePacked, lipsa marcării revendicărilor, rădăcina modificabilă fără control și ordonarea inconsistentă a perechilor între off-chain și on-chain.

Un contract de airdrop ține doar rădăcina, iar fiecare utilizator trimite (cont, sumă, dovadă). Problemele apar la detalii.

  • Frunze de 64 de octeți: dacă frunza este keccak256(abi.encodePacked(a, b)) cu două valori de câte 32 de octeți, are aceeași formă ca un nod intern (hash-ul a doi copii). Un atacator ar putea prezenta un nod intern ca frunză. Soluția recomandată de OpenZeppelin este hash dublu: keccak256(bytes.concat(keccak256(abi.encode(account, amount)))).
  • Codificare ambiguă: encodePacked cu tipuri dinamice poate produce aceeași secvență pentru date diferite. Folosește abi.encode.
  • Revendicare multiplă: marchezi fiecare index sau cont ca revendicat înainte de transfer, ideal cu un bitmap (BitMaps din OpenZeppelin) ca să economisești gas.
  • Cine poate revendica: dacă frunza nu conține destinatarul sau dacă banii merg către msg.sender fără ca acesta să fie în frunză, oricine poate fura revendicarea altuia.
  • Consistență: biblioteca off-chain (de exemplu @openzeppelin/merkle-tree) trebuie să sorteze perechile la fel ca verificarea on-chain.
  • Administrare: dacă rădăcina poate fi schimbată, cine o poate schimba? Ideal printr-un multisig sau timelock, cu event emis.
SOLIDITY
if (claimed.get(index)) revert AlreadyClaimed();
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(index, account, amount))));
if (!MerkleProof.verify(proof, merkleRoot, leaf)) revert InvalidProof();
claimed.set(index);
token.safeTransfer(account, amount);

Testează și dovezi pentru ultimul element dintr-un arbore cu număr impar de frunze și dovezi goale.

Ce urmărește intervievatorul: La senior se verifică atenția la detaliile care transformă o idee corectă într-o vulnerabilitate. Greșeala tipică: frunze de 64 de octeți cu un singur hash și revendicări nelegate de destinatar.

EVM, gas și tranzacții

22 Junior

Ce este EVM (Ethereum Virtual Machine)?

Răspuns scurt: EVM este mașina virtuală deterministă, bazată pe stivă, care execută bytecode-ul smart contractelor pe fiecare nod Ethereum. Fiecare instrucțiune (opcode) are un cost în gas, iar toate nodurile trebuie să obțină exact același rezultat.

Codul Solidity sau Vyper se compilează în bytecode, o secvență de opcode-uri precum PUSH1, ADD, SLOAD, SSTORE, CALL. Când trimiți o tranzacție către un contract, fiecare nod execută acel bytecode în EVM și actualizează starea.

Caracteristici importante:

  • mașină pe stivă: operanzii se pun pe o stivă cu cuvinte de 256 de biți și adâncime maximă de 1024 de elemente. De aici vine eroarea „stack too deep” din Solidity, când o funcție are prea multe variabile locale accesibile simultan;
  • determinism: nu există acces la rețea, fișiere, ceas real sau numere aleatoare. Datele din exterior intră doar prin tranzacții sau prin oracole;
  • izolare: un contract își poate modifica doar propriul storage; interacțiunea cu alte contracte se face prin apeluri de mesaje;
  • gas: fiecare opcode costă, iar execuția se oprește dacă se termină gas-ul. Astfel se previn buclele infinite și abuzul de resurse.

Zone de date: stiva, memoria (temporară, pe durata apelului), storage-ul (persistent), calldata (input-ul read-only) și, de la Cancun, storage-ul tranzitoriu (TSTORE/TLOAD), care se șterge la finalul tranzacției.

Multe alte rețele sunt compatibile EVM (Layer 2 precum Arbitrum, Optimism, Base, dar și alte lanțuri), deci aceleași contracte și unelte funcționează acolo, cu mici diferențe pe care trebuie să le verifici în documentația fiecărei rețele.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul de execuție, nu doar că „rulează contracte”. Greșeala tipică: a crede că un contract poate face cereri HTTP sau poate citi ora reală.

23 Junior

Ce este gas-ul și cum se calculează taxa unei tranzacții după EIP-1559?

Răspuns scurt: Gas-ul măsoară munca de calcul și de stocare a unei tranzacții. Taxa este gasUsed * (baseFee + priorityFee), unde base fee-ul este stabilit de protocol și ars, iar priority fee-ul (tip-ul) merge la validator; plafonul total îl dai prin maxFeePerGas.

Fiecare opcode are un cost fix sau dinamic în unități de gas. Un transfer simplu de ETH costă 21.000 de gas, iar o interacțiune cu un contract costă în plus în funcție de ce face, mai ales scrierile în storage.

Distinge trei noțiuni:

  • gas limit al tranzacției: maximul de gas pe care accepți să îl consumi. Dacă execuția îl depășește, tranzacția eșuează;
  • gas used: cât s-a consumat efectiv;
  • prețul pe unitate de gas, exprimat de obicei în gwei (1 gwei = 10 la puterea 9 wei).

Cu EIP-1559 (upgrade-ul London, 2021):

  • baseFeePerGas este calculat de protocol pentru fiecare bloc. Crește când blocul anterior a fost peste ținta de umplere și scade când a fost sub. Această parte este arsă;
  • maxPriorityFeePerGas este tip-ul oferit validatorului;
  • maxFeePerGas este plafonul total pe care îl accepți.

Plătești efectiv gasUsed * min(maxFeePerGas, baseFee + maxPriorityFeePerGas), iar diferența până la plafon nu se consumă.

JavaScript
const fee = await provider.getFeeData(); // ethers v6
const tx = await signer.sendTransaction({
  to, value: ethers.parseEther("0.01"),
  maxFeePerGas: fee.maxFeePerGas,
  maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
});

Ca developer, gas-ul se reflectă direct în costul suportat de utilizatori, de aceea optimizarea lui este o întrebare frecventă la interviu.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi limita, consumul și prețul, și dacă știi structura EIP-1559. Greșeala tipică: a crede că tot fee-ul merge la validator sau că plătești mereu gasLimit * maxFeePerGas.

24 Junior

Care este diferența dintre un cont extern (EOA) și un cont de contract?

Răspuns scurt: Un EOA (externally owned account) este controlat de o cheie privată, poate iniția tranzacții și nu are cod. Un cont de contract are bytecode și storage, nu are cheie privată și execută cod doar când este apelat.

Ambele tipuri au adresă, sold în ETH și nonce, dar diferă fundamental.

EOA:

  • creat din afara lanțului, prin generarea unei chei private;
  • singurul tip care poate semna și iniția o tranzacție în modelul clasic;
  • nonce-ul numără tranzacțiile trimise.

Contract:

  • creat printr-o tranzacție de deploy sau de alt contract (CREATE, CREATE2);
  • are code (bytecode) și storage;
  • reacționează doar la apeluri; nu poate „porni singur”, deci orice acțiune programată are nevoie de cineva care trimite o tranzacție (un keeper, un bot, un utilizator);
  • nonce-ul numără contractele create de el.

Detalii utile la interviu:

  • address.code.length > 0 arată că la adresă există cod, dar nu este o verificare de securitate: în timpul constructorului un contract are încă lungimea codului zero, iar o adresă poate primi cod mai târziu;
  • account abstraction (ERC-4337) permite „smart accounts”: wallet-uri implementate ca smart contracte, cu recuperare socială, plată gas în tokenuri sau tranzacții grupate;
  • upgrade-ul Pectra (2025) a adus EIP-7702, prin care un EOA poate delega execuția către codul unui contract, ceea ce estompează și mai mult granița dintre cele două tipuri.

Concluzia practică: nu-ți baza logica pe presupunerea că un apelant este „om” sau „contract”.

Ce urmărește intervievatorul: Se verifică dacă știi diferențele și capcana verificării code.length. Greșeala tipică: a crede că un contract își poate executa singur funcțiile la un interval de timp.

25 Junior

Ce este nonce-ul unui cont și ce se întâmplă dacă o tranzacție rămâne blocată?

Răspuns scurt: Nonce-ul este numărul de ordine al tranzacțiilor trimise de un EOA, începând de la 0. Tranzacțiile se execută strict în ordinea nonce-ului, deci una blocată (cu fee prea mic) le blochează pe toate cele de după ea.

Nonce-ul are două roluri: previne refolosirea unei tranzacții semnate (replay) și impune ordinea. Dacă ultima tranzacție confirmată are nonce 7, următoarea trebuie să aibă exact 8. O tranzacție cu nonce 9 așteaptă în mempool până apare 8.

Situație tipică: trimiți o tranzacție cu fee prea mic, nu este inclusă, iar următoarele tranzacții rămân și ele în așteptare. Ai două variante:

  • accelerare: retrimiți aceeași tranzacție, cu același nonce, dar cu fee mai mare (nodurile cer de obicei o creștere minimă, în jur de 10%, pentru înlocuire);
  • anulare: trimiți către propria adresă o tranzacție de 0 ETH cu același nonce și fee mai mare. Dacă ea intră prima, originalul devine invalid.
JavaScript
const nonce = await provider.getTransactionCount(addr, "pending");
await signer.sendTransaction({ to: addr, value: 0n, nonce, maxFeePerGas, maxPriorityFeePerGas });

Probleme frecvente în backend-uri care trimit tranzacții automat:

  • mai multe procese folosesc același cont și își calculează independent nonce-ul, rezultând coliziuni;
  • citirea nonce-ului cu tag-ul latest în loc de pending ignoră tranzacțiile încă neincluse.

Soluția este un singur serviciu care gestionează nonce-urile pentru un cont, cu o coadă și cu logică de înlocuire a tranzacțiilor blocate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai trimis tranzacții din cod și ai întâlnit situația unui nonce blocat. Greșeala tipică: a nu ști că poți înlocui o tranzacție folosind același nonce.

26 Junior

Care este diferența dintre un apel de citire (eth_call) și o tranzacție?

Răspuns scurt: Un eth_call execută codul local pe un nod, fără să modifice starea, fără semnătură și fără cost. O tranzacție este semnată, se propagă în rețea, este inclusă într-un bloc, poate modifica starea și costă gas.

Când apelezi din ethers.js o funcție view sau pure, biblioteca folosește eth_call. Nodul rulează funcția pe starea unui bloc (implicit latest) și îți întoarce rezultatul. Nimic nu ajunge în blockchain, deci nu plătești și nu aștepți confirmare.

Când apelezi o funcție care modifică starea (de exemplu transfer), ai nevoie de o tranzacție: wallet-ul o semnează, ea intră în mempool, un validator o include într-un bloc, iar toate nodurile o execută. Plătești gas și primești un receipt cu status, gas consumat și events.

Detalii utile:

  • poți folosi eth_call și pe o funcție care modifică starea, ca simulare: vezi dacă ar da revert și ce ar întoarce, fără să trimiți nimic. În ethers v6 se face cu contract.metodă.staticCall(...);
  • eth_estimateGas folosește același mecanism ca să estimeze gas-ul necesar;
  • funcțiile view apelate din interiorul unei tranzacții costă gas, pentru că fac parte din execuția acelei tranzacții;
  • valoarea returnată de o funcție care modifică starea nu ajunge la apelantul off-chain după tranzacție. Dacă vrei să o afli, o emiți într-un event.
JavaScript
const bal = await token.balanceOf(user);               // eth_call, gratuit
const ok = await token.transfer.staticCall(to, 100n); // simulare
const tx = await token.transfer(to, 100n);            // tranzacție reală
await tx.wait();

Ce urmărește intervievatorul: Se verifică dacă știi ce este gratuit și ce nu, și cum simulezi. Greșeala tipică: a aștepta valoarea returnată de o funcție de scriere direct din obiectul tranzacției.

27 Junior

Ce se întâmplă cu starea și cu gas-ul când o tranzacție dă revert sau rămâne fără gas?

Răspuns scurt: La revert, toate modificările de stare făcute de tranzacție sunt anulate, dar gas-ul consumat până în acel punct se plătește. Cu REVERT, gas-ul rămas se returnează, iar la epuizarea gas-ului se consumă tot gas limit-ul.

Execuția în EVM este atomică la nivel de tranzacție: fie se aplică toate efectele, fie niciunul. Când apare un revert (din require, revert, o eroare custom sau o excepție precum împărțirea la zero în Solidity 0.8), se anulează scrierile în storage, transferurile de ETH și events-urile emise în acea tranzacție.

Gas-ul este însă plătit, pentru că validatorii au făcut munca de execuție. Diferențe:

  • opcode-ul REVERT (folosit de require și revert) oprește execuția și returnează gas-ul neconsumat;
  • out of gas consumă tot gas limit-ul tranzacției;
  • assert eșuat în Solidity 0.8 produce o eroare Panic, care se comportă tot ca un REVERT; înainte de 0.8, folosea un opcode invalid care consuma tot gas-ul.

Tranzacția eșuată apare totuși în bloc, cu status = 0 în receipt, și nonce-ul expeditorului crește.

Subapelurile pot fi tratate separat: dacă contractul A apelează B cu call de nivel jos sau cu try/catch, iar B dă revert, se anulează doar efectele lui B, iar A poate continua.

SOLIDITY
(bool ok, ) = target.call(data);
if (!ok) emit CallFailed(target); // efectele lui target au fost anulate, ale noastre rămân

Practic, de aceea simulezi tranzacțiile cu estimateGas sau staticCall înainte de trimitere: un revert detectat local nu costă nimic.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi atomicitatea și cine plătește pentru eșecuri. Greșeala tipică: a crede că o tranzacție eșuată nu costă nimic sau că nu apare în blockchain.

28 Mid

Ce zone de date are EVM (stack, memory, calldata, storage) și de ce diferă atât de mult costurile lor?

Răspuns scurt: Stack-ul și memoria sunt temporare și ieftine, calldata este input-ul read-only al apelului, iar storage-ul este persistent și scump, pentru că fiecare nod trebuie să-l păstreze pentru totdeauna. De la EIP-2929, primul acces la un slot (cold) costă mult mai mult decât accesările următoare (warm).

  • Stack: maximum 1024 de cuvinte de 256 de biți, operații de câțiva gas. Aici trăiesc variabilele locale de tip valoare.
  • Memory: o zonă liniară de octeți, ștearsă la sfârșitul apelului. Costul crește liniar, apoi pătratic cu dimensiunea folosită, deci alocările mari devin scumpe.
  • Calldata: datele trimise în tranzacție sau apel, doar de citit. Citirea este ieftină, iar pe Layer 2 calldata este adesea componenta principală a costului.
  • Storage: o mapare de la sloturi de 32 de octeți la valori de 32 de octeți, persistentă. Este cea mai scumpă zonă.
  • Transient storage (Cancun, EIP-1153): ca storage-ul, dar resetat la sfârșitul tranzacției, la cost apropiat de un acces warm.

Costuri orientative după Berlin (EIP-2929) și London (EIP-3529):

  • SLOAD cold costă 2100 de gas, iar warm 100;
  • SSTORE care schimbă un slot din zero în nenul costă 20.000 de gas, plus suplimentul de acces cold;
  • modificarea unei valori nenule existente costă în jur de 2900 de gas, plus suplimentul cold;
  • readucerea unui slot la zero dă un refund parțial, plafonat la o cincime din gas-ul tranzacției.

Motivul este economic: memoria dispare după execuție, dar storage-ul mărește starea pe care orice nod trebuie să o păstreze. Consecința practică: citești o variabilă de storage o dată într-o variabilă locală, scrii cât mai rar și grupezi valori mici în același slot.

Ce urmărește intervievatorul: Se verifică dacă știi de unde vin diferențele de cost și cum influențează designul. Greșeala tipică: citirea repetată a aceleiași variabile de storage într-o buclă.

29 Mid

Cum se calculează adresa unui contract creat cu CREATE și cu CREATE2?

Răspuns scurt: Cu CREATE, adresa este derivată din adresa creatorului și nonce-ul lui, deci depinde de ordinea deploy-urilor. Cu CREATE2, adresa este keccak256(0xff ++ creator ++ salt ++ keccak256(initCode)), deci se poate calcula dinainte, indiferent de nonce.

CREATE: adresa este ultimii 20 de octeți din keccak256(rlp([creator, nonce])). Pentru un EOA, nonce-ul este numărul de tranzacții trimise; pentru un contract, numărul de contracte create. Dacă faci deploy-uri în altă ordine, obții alte adrese.

CREATE2 (EIP-1014, Constantinople): adresa este ultimii 20 de octeți din keccak256(0xff ++ creator ++ salt ++ keccak256(initCode)). Nu depinde de nonce, deci:

  • poți calcula adresa înainte de deploy și poți trimite deja fonduri la ea (counterfactual deployment);
  • poți obține aceeași adresă pe mai multe lanțuri, dacă folosești același factory la aceeași adresă, același salt și același bytecode;
  • wallet-urile ERC-4337 folosesc des această proprietate.
SOLIDITY
contract Factory {
    function deploy(bytes32 salt) external returns (address a) {
        a = address(new Vault{salt: salt}(msg.sender));
    }

    function predict(bytes32 salt, address owner) external view returns (address) {
        bytes32 h = keccak256(abi.encodePacked(
            bytes1(0xff), address(this), salt,
            keccak256(abi.encodePacked(type(Vault).creationCode, abi.encode(owner)))
        ));
        return address(uint160(uint256(h)));
    }
}

Atenție: argumentele constructorului fac parte din initCode, deci schimbă adresa. Un al doilea deploy cu același salt și același cod eșuează cât timp există cod la acea adresă. Înainte de EIP-6780 se putea combina CREATE2 cu selfdestruct pentru a pune alt cod la aceeași adresă, un risc pe care trebuie să-l cunoști când analizezi contracte vechi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce CREATE2 permite adrese predictibile și ce intră în calcul. Greșeala tipică: a uita că argumentele constructorului schimbă adresa.

30 Mid

Care este diferența dintre msg.sender și tx.origin și de ce nu folosești tx.origin pentru autorizare?

Răspuns scurt: msg.sender este apelantul direct al funcției curente, EOA sau contract. tx.origin este EOA-ul care a semnat tranzacția inițială. Autorizarea pe tx.origin permite unui contract rău intenționat să acționeze în numele victimei care l-a apelat.

Într-un lanț de apeluri Alice (EOA) -> Contract A -> Contract B:

  • în A, msg.sender este Alice, iar tx.origin este Alice;
  • în B, msg.sender este A, iar tx.origin este tot Alice.

Atacul clasic: un wallet contract verifică require(tx.origin == owner). Atacatorul o convinge pe proprietară să interacționeze cu un contract aparent inofensiv (de exemplu un „claim” de NFT). Acel contract apelează wallet-ul victimei și cere un transfer către atacator. În wallet, tx.origin este proprietara, deci verificarea trece.

SOLIDITY
// GREȘIT
function withdraw(address to, uint256 amt) external {
    require(tx.origin == owner, "not owner");
    payable(to).transfer(amt);
}

// CORECT
function withdraw(address to, uint256 amt) external {
    require(msg.sender == owner, "not owner");
    payable(to).transfer(amt);
}

Folosirea require(msg.sender == tx.origin) ca să interzici contractele apelante este și ea problematică: blochează wallet-urile de tip smart account (multisig, ERC-4337) și nu mai este o garanție solidă după EIP-7702, prin care un EOA poate avea cod delegat.

Singurul loc rezonabil pentru tx.origin este informativ, de exemplu în statistici, niciodată în logica de permisiuni.

Ce urmărește intervievatorul: Se verifică dacă știi diferența și atacul de tip phishing. Greșeala tipică: a folosi msg.sender == tx.origin ca protecție anti-bot fără a înțelege ce utilizatori legitimi blochează.

31 Mid

Ce este mempool-ul și cum ajunge o tranzacție într-un bloc?

Răspuns scurt: Mempool-ul este colecția de tranzacții valide, încă neincluse, pe care fiecare nod o ține local. Validatorul care propune blocul (de obicei prin builderi externi, prin MEV-Boost) alege tranzacțiile și ordinea lor, în general după profitul obținut.

Drumul unei tranzacții:

  • wallet-ul o semnează și o trimite unui nod prin eth_sendRawTransaction;
  • nodul verifică semnătura, nonce-ul, soldul suficient pentru fee-ul maxim și o propagă altor noduri prin rețeaua peer-to-peer;
  • tranzacția stă în mempool-ul fiecărui nod, care are reguli proprii de limită și de evacuare;
  • propunătorul slotului construiește blocul sau, mai des pe Ethereum, primește un bloc gata construit de la un builder prin relay-uri (arhitectura MEV-Boost, proposer-builder separation);
  • builderul ordonează tranzacțiile ca să maximizeze tip-urile și oportunitățile de MEV (maximal extractable value).

Consecințe pentru un developer:

  • mempool-ul public este vizibil: oricine vede tranzacția ta înainte să fie inclusă, cu tot cu parametri. De aici vin front-running și sandwich attacks;
  • există mempool-uri private sau RPC-uri de protecție, unde tranzacția merge direct la builderi, fără să fie expusă public;
  • ordinea nu este „primul venit, primul servit”; tip-ul și strategiile builderilor contează;
  • pe multe Layer 2, un sequencer ordonează tranzacțiile, adesea în ordinea primirii, și nu există un mempool public în sensul de pe Layer 1.
JavaScript
const tx = await signer.sendTransaction({ to, value });
console.log(tx.hash);        // tranzacția e în mempool
const rc = await tx.wait(2); // așteaptă includerea plus o confirmare suplimentară

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi că ordonarea este controlată de producătorul blocului și că mempool-ul este public. Greșeala tipică: a presupune ordine FIFO și confidențialitate până la includere.

32 Senior

Explică delegatecall: ce context păstrează și ce pericole aduce.

Răspuns scurt: delegatecall execută codul altui contract în contextul contractului apelant: același storage, același msg.sender, același msg.value. Este baza proxy-urilor și a bibliotecilor, dar poate corupe storage-ul sau preda controlul complet unui cod străin.

La un call obișnuit de la A la B, codul lui B rulează pe storage-ul lui B, iar msg.sender devine A. La delegatecall, codul lui B rulează ca și cum ar fi al lui A: scrie în storage-ul lui A, vede msg.sender și msg.value ale apelului inițial către A, iar address(this) este A.

De aceea un proxy poate avea storage-ul, iar logica stă într-un contract de implementare înlocuibil.

Pericole:

  • coliziuni de storage: codul lui B folosește layout-ul de variabile al lui B, dar scrie în sloturile lui A. Dacă slotul 0 este owner în A și counter în B, incrementarea contorului suprascrie proprietarul;
  • delegatecall către o adresă controlată de utilizator: atacatorul poate rula orice cod pe storage-ul tău, inclusiv să schimbe proprietarul sau să golească fondurile;
  • implementări neinițializate: dacă implementarea unui proxy are o funcție initialize neapelată direct pe ea, un atacator o poate inițializa și, în unele modele vechi, poate executa selfdestruct prin delegatecall, lăsând proxy-ul fără logică (incidentul Parity din 2017 a pornit de aici).
SOLIDITY
// Periculos: oricine poate executa cod arbitrar în contextul acestui contract
function exec(address target, bytes calldata data) external {
    (bool ok, ) = target.delegatecall(data);
    require(ok);
}

Reguli: delegatecall doar către cod de încredere, fix sau administrat strict; layout de storage compatibil (sau sloturi ERC-1967 și namespaced storage ERC-7201); constructor cu _disableInitializers() în implementări.

Ce urmărește intervievatorul: La senior se așteaptă înțelegerea profundă a contextului de execuție și a incidentelor reale. Greșeala tipică: a crede că delegatecall doar „apelează o funcție din altă parte”.

33 Senior

Cum sunt așezate variabilele în storage-ul unui contract Solidity, inclusiv mapările și array-urile dinamice?

Răspuns scurt: Variabilele de stare ocupă sloturi de 32 de octeți în ordinea declarării, iar valorile mici consecutive se împachetează. Pentru o mapare la slotul p, m[k] stă la keccak256(abi.encode(k, p)); la un array dinamic, lungimea e în p, iar elementele încep la keccak256(p).

Reguli principale (Solidity, layout standard):

  • sloturile pornesc de la 0, în ordinea declarării, inclusiv cele moștenite, de la contractul de bază spre cel derivat;
  • tipurile mai mici de 32 de octeți se pun în același slot dacă încap, aliniate la dreapta. uint128 a; uint128 b; ocupă un slot, dar uint128 a; uint256 b; uint128 c; ocupă trei;
  • structurile și array-urile statice încep mereu la un slot nou;
  • constant și immutable nu ocupă storage: sunt în bytecode.

Tipuri dinamice:

  • mapping la slotul p: slotul p rămâne gol, iar m[k] este la keccak256(abi.encode(k, p)). Mapările imbricate aplică formula recursiv;
  • array dinamic la slotul p: lungimea în p, elementul i la keccak256(p) + i (ajustat pentru elemente împachetate);
  • bytes și string: dacă au cel mult 31 de octeți, se țin direct în slot, împreună cu lungimea; altfel, ca un array.
SOLIDITY
contract C {
    address owner;      // slot 0 (20 de octeți)
    bool paused;        // tot slot 0, împachetat
    uint256 total;      // slot 1
    mapping(address => uint256) bal; // slot 2; bal[u] la keccak256(abi.encode(u, 2))
}

De ce contează: optimizarea gas-ului prin ordonarea variabilelor, citirea directă din storage cu eth_getStorageAt sau vm.load în teste, și mai ales compatibilitatea layout-ului la contractele upgradeable. Comanda forge inspect C storageLayout îți arată layout-ul real.

Ce urmărește intervievatorul: Se verifică înțelegerea la nivel de implementare, necesară pentru optimizare, proxy-uri și audit. Greșeala tipică: a crede că variabilele private nu pot fi citite din afară.

Solidity

34 Junior

Cum arată structura unui contract Solidity minimal? Explică fiecare parte.

Răspuns scurt: Un contract are un comentariu de licență SPDX, pragma solidity cu versiunea compilatorului, eventual importuri, apoi contract Nume { ... } cu variabile de stare, events, erori, constructor, modifiers și funcții.

Un exemplu complet, dar mic:

SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Counter {
    address public immutable owner;
    uint256 public count;

    event Incremented(address indexed by, uint256 newCount);
    error NotOwner();

    constructor() {
        owner = msg.sender;
    }

    function increment() external {
        count += 1;
        emit Incremented(msg.sender, count);
    }

    function reset() external {
        if (msg.sender != owner) revert NotOwner();
        count = 0;
    }
}

Explicații:

  • SPDX: compilatorul emite un avertisment dacă lipsește; indică licența codului sursă publicat;
  • pragma: ^0.8.24 înseamnă orice versiune de la 0.8.24 inclusiv, dar sub 0.9.0. Pentru deploy în producție se preferă o versiune fixă, ca bytecode-ul să fie reproductibil;
  • variabile de stare: count este în storage; public generează automat un getter count(). immutable se setează o dată în constructor și se păstrează în bytecode;
  • event: log ieftin, citit off-chain;
  • custom error: introduse în 0.8.4, mai ieftine decât mesajele text la revert;
  • constructor: rulează o singură dată, la deploy, și nu face parte din codul final al contractului;
  • funcții: external pentru apeluri din afară; din 0.8.0 aritmetica verifică automat overflow-ul.

La interviu poți fi rugat să scrii exact un asemenea contract, deci exersează-l până îl poți scrie fără documentație.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai scris efectiv Solidity și cunoști elementele de bază. Greșeala tipică: confuzia între ^0.8.x și o versiune fixă sau neștiința că public generează getter.

35 Junior

Ce tipuri de vizibilitate există în Solidity și ce înseamnă de fapt private?

Răspuns scurt: Funcțiile pot fi public, external, internal sau private, iar variabilele de stare public, internal (implicit) sau private. private înseamnă doar că alte contracte nu le pot accesa prin cod; datele rămân citibile de oricine direct din blockchain.

Pentru funcții:

  • public: apelabilă din exterior și din interiorul contractului;
  • external: apelabilă doar din exterior (sau intern prin this.f(), care face un apel extern și costă mai mult). Parametrii de tip referință pot fi calldata;
  • internal: doar din contract și din contractele care îl moștenesc;
  • private: doar din contractul în care este definită, nu și din cele derivate.

Pentru variabile de stare:

  • public: compilatorul generează un getter; pentru o mapare, getter-ul primește cheia ca parametru;
  • internal (implicit): accesibilă în contract și în cele derivate;
  • private: doar în contractul curent.

Capcana principală: private nu este confidențialitate. Tot storage-ul unui contract este public, iar oricine îl poate citi cu eth_getStorageAt dacă știe slotul:

JavaScript
// ethers v6: citește slotul 0 al contractului
const raw = await provider.getStorage(contractAddress, 0);

De aceea nu stochezi parole, chei, răspunsuri la ghicitori sau alte secrete în contracte, nici măcar „private”. Dacă ai nevoie de date ascunse temporar, folosești commit-reveal; dacă ai nevoie de date confidențiale permanent, ele nu își au locul pe un blockchain public, sau folosești criptografie specializată.

O regulă bună de review: orice funcție care schimbă starea și este public sau external trebuie să aibă o decizie explicită despre cine are voie să o apeleze.

Ce urmărește intervievatorul: Se verifică dacă știi diferențele și, mai ales, mitul confidențialității private. Este una dintre cele mai frecvente greșeli ale începătorilor.

36 Junior

Ce înseamnă modificatorii view, pure și payable pentru o funcție?

Răspuns scurt: view promite că funcția doar citește starea, pure că nici nu o citește, iar payable permite funcției să primească ETH prin msg.value. Fără payable, un apel cu ETH atașat dă revert.

Acești modificatori de mutabilitate sunt verificați de compilator.

  • view: poate citi variabile de stare, block.timestamp, solduri, dar nu poate scrie storage, emite events, trimite ETH sau apela funcții care nu sunt view/pure.
  • pure: nu citește și nu scrie starea. Lucrează doar cu parametrii și cu variabilele locale, de exemplu calcule matematice sau codificări.
  • payable: funcția poate primi ETH. Valoarea primită este în msg.value, în wei. Constructorul poate fi și el payable.
SOLIDITY
uint256 public fee = 0.01 ether;
mapping(address => uint256) public paid;

function quote(uint256 qty) external view returns (uint256) {
    return qty * fee;
}

function square(uint256 x) external pure returns (uint256) {
    return x * x;
}

function buy(uint256 qty) external payable {
    require(msg.value == qty * fee, "suma gresita");
    paid[msg.sender] += msg.value;
}

Detalii care apar la interviu:

  • apelate din afara unei tranzacții (prin eth_call), funcțiile view și pure nu costă nimic; apelate în cadrul unei tranzacții, consumă gas;
  • în bytecode, apelurile către funcții view se fac cu STATICCALL, care dă revert dacă încearcă cineva să modifice starea;
  • o adresă trebuie să fie de tip address payable ca să poți apela .transfer sau .send pe ea; de exemplu payable(msg.sender).

O greșeală frecventă este să marchezi o funcție payable fără să tratezi ETH-ul primit, iar banii rămân blocați în contract.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica și costurile. Greșeala tipică: a crede că funcțiile view sunt gratuite în orice context.

37 Junior

Ce afișează get() în codul de mai jos și de ce? (storage vs memory pentru structuri)

Răspuns scurt: get() întoarce 1. În incMemory, memory creează o copie a structurii, deci modificarea se pierde; în incStorage, storage creează o referință către datele persistente, deci modificarea rămâne.

Codul:

SOLIDITY
contract Demo {
    struct User { uint256 points; }
    mapping(address => User) users;

    function incMemory() external {
        User memory u = users[msg.sender];
        u.points += 1;          // modifică doar copia
    }

    function incStorage() external {
        User storage u = users[msg.sender];
        u.points += 1;          // modifică storage-ul
    }

    function get() external view returns (uint256) {
        return users[msg.sender].points;
    }
}

Dacă apelezi incMemory(), apoi incStorage(), apoi get(), rezultatul este 1.

Regula: pentru tipurile referință (struct, array, mapping, string, bytes) trebuie să indici locația datelor:

  • storage: referință către date persistente. Orice modificare se scrie în blockchain;
  • memory: copie temporară, valabilă pe durata apelului;
  • calldata: referință read-only la datele de intrare, disponibilă pentru parametrii funcțiilor external (și, din 0.6.9, pentru orice funcție).

Atribuirea dintre locații are reguli precise: de la storage la memory se copiază; de la storage la o variabilă locală storage se creează o referință; de la memory la o variabilă de stare se copiază.

Implicații de gas: copierea unei structuri mari în memory citește toate câmpurile din storage, deci poate fi scumpă. Dacă ai nevoie de un singur câmp, accesează-l direct sau folosește o referință storage. Pentru parametri pe care doar îi citești, calldata este de obicei cea mai ieftină variantă.

Ce urmărește intervievatorul: Este o întrebare clasică de tipul „ce afișează”, care verifică înțelegerea copiilor vs referințelor. Mulți candidați răspund 2, presupunând că ambele funcții modifică storage-ul.

38 Junior

Ce este un mapping în Solidity și de ce nu poți itera peste el?

Răspuns scurt: Un mapping este o tabelă cheie-valoare în care orice cheie există implicit cu valoarea zero. Nu poți itera pentru că nu se păstrează lista cheilor: valoarea fiecărei chei se află la un slot calculat prin hash, fără o evidență a cheilor folosite.

Declarația mapping(address => uint256) public balances; îți dă acces în timp constant la balances[user]. Dacă nimeni nu a scris niciodată pentru acea adresă, rezultatul este 0, nu o eroare. Nu există conceptul de „cheie inexistentă”.

De ce nu se poate itera: valoarea pentru cheia k se află la keccak256(abi.encode(k, slot)). Spațiul de chei este uriaș, iar contractul nu salvează nicăieri ce chei au fost scrise. Nu există nici length.

Ce faci când ai nevoie de listare:

  • păstrezi în paralel un array de chei, cu grijă la duplicate și la ștergere;
  • folosești EnumerableSet sau EnumerableMap din OpenZeppelin, care gestionează corect adăugarea și ștergerea în timp constant;
  • mai des și mai ieftin: emiți events la fiecare modificare și construiești lista off-chain, într-un indexer.
SOLIDITY
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private members;

function add(address a) external onlyOwner { members.add(a); }
function count() external view returns (uint256) { return members.length(); }

Atenție: chiar dacă poți enumera, o buclă on-chain peste o listă care crește nelimitat poate depăși limita de gas a blocului și bloca funcționalitatea. Enumerarea on-chain e bună pentru citiri off-chain sau pentru liste mici și limitate.

Încă un detaliu: un mapping nu poate fi șters integral cu delete; ștergi doar intrări individuale.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul de date și alternativele (events, seturi enumerabile). Greșeala tipică: a propune o buclă on-chain peste toți utilizatorii.

39 Junior

Ce este un modifier în Solidity? Scrie un onlyOwner.

Răspuns scurt: Un modifier este o bucată de cod reutilizabilă care se execută înainte și/sau după corpul unei funcții, de obicei pentru verificări de permisiuni sau de stare. Simbolul _ marchează locul unde se inserează corpul funcției.

Exemplu:

SOLIDITY
contract Owned {
    address public owner;
    error NotOwner();

    constructor() { owner = msg.sender; }

    modifier onlyOwner() {
        if (msg.sender != owner) revert NotOwner();
        _;
    }

    function setOwner(address newOwner) external onlyOwner {
        require(newOwner != address(0), "adresa zero");
        owner = newOwner;
    }
}

Cum funcționează: compilatorul copiază codul modifier-ului în fiecare funcție care îl folosește și înlocuiește _ cu corpul funcției. Poți aplica mai mulți modifiers, care se execută în ordinea în care îi scrii, iar modifiers pot primi parametri, de exemplu onlyRole(ADMIN_ROLE).

Bune practici:

  • folosește modifiers pentru verificări simple; logica complexă într-un modifier face codul greu de citit;
  • dacă modifier-ul are mult cod și e folosit în multe funcții, mută verificarea într-o funcție internal și apeleaz-o din modifier, ca să reduci dimensiunea bytecode-ului (limita este 24 KB, conform EIP-170);
  • evită modifiers care fac apeluri externe sau modifică starea în mod neașteptat;
  • în proiecte reale, folosește Ownable, Ownable2Step sau AccessControl din OpenZeppelin în loc să scrii de la zero. Ownable2Step cere ca noul proprietar să accepte transferul, ceea ce previne transferul accidental către o adresă greșită.

Codul de după _ se execută după corpul funcției, dar nu și dacă funcția face return direct din modifier.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să scrii și să folosești corect modifiers și dacă știi de alternativele standard. Greșeala tipică: lipsa verificării adresei zero la transferul de proprietate.

40 Junior

Ce sunt events în Solidity, ce înseamnă indexed și de ce le folosești?

Răspuns scurt: Events sunt loguri emise în receipt-ul tranzacției, ieftine comparativ cu storage-ul și citibile off-chain, dar nu și din contracte. Parametrii indexed devin topics, după care aplicațiile pot filtra eficient (maxim trei pentru un event obișnuit).

Un event declară o structură de log, iar emit îl scrie:

SOLIDITY
event Transfer(address indexed from, address indexed to, uint256 value);

function _transfer(address from, address to, uint256 value) internal {
    // ... actualizează soldurile
    emit Transfer(from, to, value);
}

La nivel EVM, un log are până la 4 topics de câte 32 de octeți și o zonă de data. Primul topic este hash-ul semnăturii (keccak256("Transfer(address,address,uint256)")), deci rămân trei pentru parametrii indexed. Restul parametrilor se codifică în data.

De ce le folosești:

  • front-end și backend: aplicația afișează istoricul sau reacționează la acțiuni fără să interogheze tot storage-ul;
  • indexare: The Graph sau un indexer propriu construiesc baze de date din events;
  • cost: un log este mult mai ieftin decât păstrarea aceleiași informații în storage;
  • auditabilitate: orice schimbare administrativă importantă (rol nou, parametru modificat) ar trebui să emită un event.

Limitări:

  • contractele nu pot citi events, nici pe ale lor;
  • un parametru indexed de tip dinamic (string, bytes, array) este stocat ca hash, deci poți filtra după el, dar nu-i mai poți citi valoarea originală din topic;
  • events dintr-o tranzacție care dă revert nu există.
JavaScript
const logs = await token.queryFilter(token.filters.Transfer(null, myAddress), -5000);

Ce urmărește intervievatorul: Se verifică dacă știi ce sunt topics și de ce events sunt fundamentul integrării off-chain. Greșeala tipică: a crede că un contract poate citi events emise anterior.

41 Junior

Care este diferența dintre require, revert, assert și custom errors?

Răspuns scurt: require verifică o condiție și dă revert dacă nu e îndeplinită, revert oprește explicit execuția, iar assert este pentru invarianți interni care nu ar trebui să eșueze niciodată. Custom errors sunt mai ieftine și pot transporta parametri.

  • require(cond, "mesaj"): pentru validarea input-urilor, a permisiunilor și a stării. Dacă cond este fals, se produce revert cu Error(string).
  • revert(...): util în logica cu if, mai ales împreună cu erori custom.
  • assert(cond): semnalează o eroare de programare. În Solidity 0.8, eșecul produce Panic(uint256) cu un cod; overflow-ul și împărțirea la zero produc și ele Panic. Un assert eșuat în producție înseamnă un bug.
  • Custom errors (de la 0.8.4): error InsufficientBalance(uint256 available, uint256 required); Sunt identificate printr-un selector de 4 octeți, nu printr-un string, deci costă mai puțin la deploy și la execuție, iar parametrii dau context.
SOLIDITY
error InsufficientBalance(uint256 available, uint256 required);

function withdraw(uint256 amount) external {
    uint256 bal = balances[msg.sender];
    if (bal < amount) revert InsufficientBalance(bal, amount);
    balances[msg.sender] = bal - amount;
    // ...
}

Din Solidity 0.8.26, require acceptă și o eroare custom ca al doilea argument, inițial doar cu pipeline-ul via-IR, iar din 0.8.27 și cu pipeline-ul legacy: require(bal >= amount, InsufficientBalance(bal, amount));.

Off-chain, ethers.js poate decoda erorile custom dacă are ABI-ul care le conține, iar în teste verifici exact eroarea, nu doar faptul că a dat revert.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești instrumentul potrivit pentru fiecare situație. Greșeala tipică: a folosi assert pentru validarea input-ului utilizatorului.

42 Junior

Cum primește ETH un contract? Ce rol au receive și fallback?

Răspuns scurt: Un contract primește ETH prin funcții payable, prin receive() când i se trimite ETH fără date, sau prin fallback() când nu se potrivește nicio funcție. Fără receive sau fallback payable, un transfer simplu de ETH către contract dă revert.

Regulile de dispecerizare când un contract primește un apel:

  • dacă calldata începe cu selectorul unei funcții existente, se apelează acea funcție;
  • dacă calldata este gol și există receive() external payable, se apelează receive;
  • altfel, se apelează fallback(), dacă există. Pentru a primi ETH, fallback trebuie să fie payable;
  • dacă nu există nimic potrivit, apelul dă revert.
SOLIDITY
contract Vault {
    event Received(address from, uint256 amount);

    receive() external payable {
        emit Received(msg.sender, msg.value);
    }

    fallback() external payable {
        revert("functie inexistenta");
    }
}

Detalii importante:

  • dacă ETH-ul este trimis cu .transfer sau .send, receive are la dispoziție doar 2300 de gas, suficient pentru un event, dar nu pentru scrieri în storage;
  • un contract poate primi ETH și fără să i se execute codul: ca destinatar al recompenselor de bloc sau al retragerilor de validator, ori de la selfdestruct al altui contract. De aceea nu te baza pe address(this).balance ca reflectare exactă a depozitelor făcute prin funcțiile tale;
  • fallback este folosit de proxy-uri, care redirecționează orice apel necunoscut către implementare prin delegatecall;
  • un receive care dă mereu revert te poate împiedica să primești plăți legitime sau poate fi exploatat pentru a bloca un contract care îți trimite bani (DoS).

Ține contabilitatea internă în variabile proprii, nu în soldul contractului.

Ce urmărește intervievatorul: Se verifică regulile de dispecerizare și cazurile neașteptate de primire a ETH. Greșeala tipică: a crede că un contract fără receive nu poate avea niciodată sold.

43 Mid

Cum funcționează moștenirea în Solidity: virtual, override, super și ordinea de liniarizare?

Răspuns scurt: Solidity permite moștenire multiplă, rezolvată prin liniarizare C3. Funcțiile care pot fi suprascrise trebuie marcate virtual, cele care suprascriu override, iar super apelează următoarea implementare din ordinea liniarizată, nu neapărat părintele direct.

Exemplu:

SOLIDITY
contract A {
    function hello() public pure virtual returns (string memory) { return "A"; }
}
contract B is A {
    function hello() public pure virtual override returns (string memory) {
        return string.concat("B", super.hello());
    }
}
contract C is A {
    function hello() public pure virtual override returns (string memory) {
        return string.concat("C", super.hello());
    }
}
contract D is B, C {
    function hello() public pure override(B, C) returns (string memory) {
        return super.hello();
    }
}

D.hello() întoarce "CBA". Ordinea liniarizată pentru D este D, C, B, A: super din D merge la C, super din C merge la B (nu la A), iar B ajunge la A.

Reguli:

  • părinții se listează de la „cel mai de bază” la „cel mai derivat”. contract D is B, C înseamnă că C are prioritate față de B;
  • când două baze definesc aceeași funcție, contractul derivat trebuie să o suprascrie explicit cu override(B, C);
  • constructorii părinților se execută în ordinea liniarizării, iar argumentele se pot da în lista de moștenire sau în constructor;
  • variabilele de stare ale părinților ocupă storage-ul în aceeași ordine, ceea ce contează la upgrade-uri.

În practică, moștenirea apare zilnic cu OpenZeppelin, de exemplu contract MyToken is ERC20, ERC20Permit, Ownable, iar hook-urile, precum _update în ERC20 v5, se suprascriu și apelează super.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi liniarizarea, nu doar sintaxa. Greșeala tipică: a crede că super apelează mereu părintele direct și a răspunde „BA” la exemplu.

44 Mid

Care este diferența dintre o interfață, un contract abstract și o bibliotecă (library)?

Răspuns scurt: O interfață declară doar semnături de funcții externe, fără implementare și fără stare. Un contract abstract poate avea implementări parțiale și stare, dar nu poate fi deployat direct. O bibliotecă grupează funcții reutilizabile, fără stare proprie și fără să poată primi ETH.

Interfața (interface IERC20 { ... }):

  • doar declarații de funcții external, events, erori, structuri și enum-uri;
  • fără constructor, fără variabile de stare, fără implementări;
  • se folosește pentru a apela alte contracte: IERC20(token).transfer(to, amount). Compilatorul generează codificarea corectă a apelului.

Contractul abstract (abstract contract Base { ... }):

  • poate avea funcții fără implementare (marcate virtual), dar și cod complet, variabile de stare, constructor;
  • nu poate fi deployat; trebuie moștenit de un contract care implementează funcțiile lipsă;
  • bun pentru un schelet comun, de exemplu un Pausable sau o bază de vault.

Biblioteca (library SafeMath { ... }):

  • fără variabile de stare proprii și fără ETH;
  • funcțiile internal sunt copiate direct în bytecode-ul contractului care le folosește;
  • funcțiile public/external necesită deploy separat și linkare, iar apelul se face prin delegatecall;
  • se folosesc des cu using X for Y, ca metode pe tipuri:
SOLIDITY
library Percent {
    function pct(uint256 amount, uint256 bps) internal pure returns (uint256) {
        return amount * bps / 10_000;
    }
}

contract Fees {
    using Percent for uint256;
    function fee(uint256 amount) external pure returns (uint256) {
        return amount.pct(30); // 0,30%
    }
}

Exemple reale din OpenZeppelin: interfața IERC20, contractul abstract ERC20, bibliotecile SafeERC20, Address, ECDSA, MerkleProof.

Ce urmărește intervievatorul: Se verifică dacă știi când alegi fiecare construcție și cum se comportă la compilare. Greșeala tipică: a nu ști că funcțiile internal ale bibliotecilor sunt incluse în bytecode.

45 Mid

Care este cel mai sigur mod de a trimite ETH dintr-un contract: transfer, send sau call?

Răspuns scurt: Recomandarea actuală este call{value: amount}("") cu verificarea rezultatului, combinată cu protecție la reentrancy. transfer și send transmit doar 2300 de gas, ceea ce poate bloca destinatarii de tip contract, mai ales dacă se schimbă costurile opcode-urilor.

  • transfer: trimite 2300 de gas și dă revert dacă destinatarul eșuează.
  • send: tot 2300 de gas, dar întoarce false la eșec, deci trebuie verificat.
  • call: transmite implicit tot gas-ul disponibil (sau cât specifici) și întoarce (bool success, bytes memory data).

Inițial, limita de 2300 de gas era văzută ca protecție la reentrancy, pentru că destinatarul nu avea suficient gas ca să reapeleze contractul. Problemele:

  • multe wallet-uri multisig și proxy-uri au nevoie de mai mult de 2300 de gas în receive, deci transfer către ele eșuează și fondurile pot rămâne blocate;
  • costurile opcode-urilor s-au schimbat de-a lungul timpului (de exemplu EIP-1884, EIP-2929), deci un cod care încăpea în 2300 de gas poate să nu mai încapă.

Varianta recomandată:

SOLIDITY
function withdraw() external nonReentrant {
    uint256 amount = balances[msg.sender];
    require(amount > 0, "nimic de retras");
    balances[msg.sender] = 0;                         // efect înainte de interacțiune
    (bool ok, ) = payable(msg.sender).call{value: amount}("");
    require(ok, "transfer esuat");
}

Elemente esențiale: actualizezi starea înainte de apel (Checks-Effects-Interactions), verifici ok și adaugi un guard de reentrancy. În plus, preferă modelul pull: utilizatorii își retrag singuri banii, în loc ca un contract să trimită plăți în buclă către mulți destinatari, unde un singur destinatar care refuză ETH ar bloca tot procesul.

Pentru tokenuri ERC-20 se aplică alte reguli, folosind SafeERC20.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce s-a schimbat recomandarea și cum previi riscurile introduse de call. Greșeala tipică: call fără verificarea rezultatului sau fără protecție la reentrancy.

46 Mid

Cum tratează Solidity 0.8 overflow-ul și când folosești unchecked?

Răspuns scurt: Din Solidity 0.8.0, operațiile aritmetice verifică automat overflow-ul și underflow-ul și dau revert cu Panic. Blocul unchecked { ... } dezactivează verificarea pentru a economisi gas acolo unde poți demonstra că depășirea este imposibilă.

Înainte de 0.8, uint8 x = 255; x + 1 dădea 0 fără eroare, iar multe exploit-uri istorice au profitat de asta. Soluția era biblioteca SafeMath. Din 0.8.0, compilatorul adaugă verificările implicit, iar SafeMath nu mai este necesară.

unchecked revine la comportamentul vechi (aritmetică modulo 2 la puterea n), deci îl folosești doar când ai o garanție logică:

SOLIDITY
function sum(uint256[] calldata xs) external pure returns (uint256 total) {
    for (uint256 i = 0; i < xs.length; ) {
        total += xs[i];          // verificat: suma poate depăși
        unchecked { ++i; }       // i < xs.length, deci nu poate depăși
    }
}

function withdraw(uint256 amount) external {
    uint256 bal = balances[msg.sender];
    require(bal >= amount, "sold insuficient");
    unchecked { balances[msg.sender] = bal - amount; } // garantat de require
}

Din Solidity 0.8.22, compilatorul elimină automat verificarea pentru incrementul contorului în buclele for simple, deci trucul cu unchecked { ++i; } nu mai este necesar în acele cazuri.

Atenție la ce nu acoperă verificarea:

  • conversiile explicite între tipuri, de exemplu uint8(uint256(300)), trunchiază fără eroare. Pentru conversii sigure folosește SafeCast din OpenZeppelin;
  • operațiile pe biți și shift-urile nu verifică depășirea;
  • codul din assembly nu are nicio verificare.

Regula de review: fiecare bloc unchecked trebuie însoțit de un comentariu care explică de ce nu poate depăși.

Ce urmărește intervievatorul: Se verifică dacă știi comportamentul implicit și riscul conversiilor. Greșeala tipică: a pune unchecked pentru economie de gas fără o garanție demonstrabilă.

47 Mid

Ce tehnici folosești ca să reduci consumul de gas al unui contract?

Răspuns scurt: Cele mai eficiente tehnici reduc accesul la storage: împachetarea variabilelor, constant și immutable, citirea storage-ului o singură dată în variabile locale, evitarea scrierilor inutile. Apoi vin custom errors, calldata pentru parametri, events în loc de storage pentru istoric și evitarea buclelor nelimitate.

Ordinea priorităților contează: un SSTORE economisit valorează mai mult decât zeci de micro-optimizări.

Storage:

  • grupează tipurile mici citite împreună în același slot: uint128 + uint64 + address de exemplu;
  • constant pentru valori cunoscute la compilare, immutable pentru valori setate în constructor; ambele evită SLOAD;
  • citește o variabilă de storage o singură dată într-o variabilă locală și scrie la final;
  • nu păstra on-chain date de care ai nevoie doar off-chain; emite un event;
  • folosește bitmap-uri pentru flag-uri booleene multe.

Execuție:

  • custom errors în loc de mesaje string lungi;
  • calldata în loc de memory pentru parametri de tip array sau string care nu se modifică;
  • external în loc de public acolo unde nu apelezi intern, pentru claritate și uneori cost;
  • evită apelurile externe repetate către același contract.

Proiectare:

  • modelul pull în loc de bucle de plăți;
  • Merkle proofs în loc de liste stocate;
  • tranzacții grupate (batch) când utilizatorul face mai multe acțiuni deodată.
SOLIDITY
// înainte: citește `total` din storage la fiecare iterație
for (uint256 i; i < items.length; ++i) total += items[i];

// după
uint256 t = total;
uint256 n = items.length;
for (uint256 i; i < n; ++i) t += items[i];
total = t;

Măsoară, nu ghici: forge snapshot, forge test --gas-report sau hardhat-gas-reporter. Activează optimizer-ul în compilator și alege valoarea runs în funcție de cât de des va fi apelat contractul. Nu sacrifica lizibilitatea și securitatea pentru câțiva gas.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce contează cu adevărat și dacă măsori. Greșeala tipică: a începe cu micro-optimizări de sintaxă și a ignora designul accesului la storage.

48 Mid

Scrie un contract simplu de tip vault în care utilizatorii depun și retrag ETH. Ce elemente nu trebuie să lipsească?

Răspuns scurt: Contractul ține soldurile într-un mapping, are deposit payable și withdraw care verifică soldul, actualizează starea înainte de trimitere, trimite cu call verificat, are protecție la reentrancy și emite events pentru ambele operații.

O implementare cu OpenZeppelin v5:

SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract EthVault is ReentrancyGuard {
    mapping(address => uint256) public balanceOf;

    event Deposited(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);

    error ZeroAmount();
    error InsufficientBalance(uint256 available, uint256 requested);
    error TransferFailed();

    function deposit() external payable {
        if (msg.value == 0) revert ZeroAmount();
        balanceOf[msg.sender] += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external nonReentrant {
        uint256 bal = balanceOf[msg.sender];
        if (amount == 0) revert ZeroAmount();
        if (bal < amount) revert InsufficientBalance(bal, amount);

        balanceOf[msg.sender] = bal - amount;           // effects
        emit Withdrawn(msg.sender, amount);

        (bool ok, ) = msg.sender.call{value: amount}(""); // interactions
        if (!ok) revert TransferFailed();
    }
}

Ce urmărește intervievatorul:

  • Checks-Effects-Interactions: verificări, apoi modificarea soldului, abia apoi trimiterea ETH;
  • nonReentrant ca a doua linie de apărare;
  • call cu rezultat verificat, nu transfer;
  • events pentru fiecare schimbare de sold;
  • erori custom cu context;
  • lipsa unei funcții receive: cine trimite ETH direct, fără deposit, primește revert, ca banii să nu ajungă necontabilizați.

Întrebări de continuare probabile: cum ai testa contractul (inclusiv un atacator care încearcă reentrancy), ce s-ar schimba pentru un vault de tokenuri ERC-20 (SafeERC20, tokenuri cu taxă la transfer) și dacă ai adăuga o funcție de pauză administrativă.

Ce urmărește intervievatorul: Este o întrebare de codare live; se verifică dacă aplici automat tiparele de securitate. Greșeala tipică: trimiterea ETH înainte de actualizarea soldului.

49 Mid

Cum apelezi un alt contract din Solidity și cum tratezi eșecul apelului?

Răspuns scurt: Varianta preferată este apelul printr-o interfață (IToken(addr).transfer(...)), care propagă revert-ul automat. Dacă vrei să tratezi eșecul fără să anulezi tot, folosești try/catch pentru apeluri externe sau call de nivel jos cu verificarea rezultatului.

Prin interfață: compilatorul codifică argumentele, verifică existența codului la adresă și decodifică rezultatul. Dacă apelul dă revert, eroarea se propagă și întreaga tranzacție este anulată.

SOLIDITY
interface IOracle { function price() external view returns (uint256); }

function current(address oracle) external view returns (uint256) {
    return IOracle(oracle).price();
}

try/catch: funcționează doar pentru apeluri externe și creare de contracte. Prinde revert-urile apelului, dar nu erorile din propriul cod din blocul try.

SOLIDITY
function safePrice(address oracle) external view returns (uint256 p, bool ok) {
    try IOracle(oracle).price() returns (uint256 v) {
        return (v, true);
    } catch Error(string memory) {
        return (0, false);   // revert cu mesaj
    } catch (bytes memory) {
        return (0, false);   // custom error, Panic sau revert gol
    }
}

call de nivel jos: (bool ok, bytes memory data) = target.call(abi.encodeCall(IOracle.price, ()));. Oferă control complet, dar:

  • un call către o adresă fără cod întoarce ok = true, deci trebuie să verifici separat target.code.length > 0 dacă te bazezi pe rezultat;
  • datele returnate pot fi foarte mari și pot consuma mult gas la copiere (return bomb), dacă destinatarul nu este de încredere;
  • trebuie să decodezi manual cu abi.decode.

Folosește abi.encodeCall în loc de abi.encodeWithSignature, pentru că verifică tipurile la compilare. Tratează orice contract extern ca potențial ostil: poate da revert, poate consuma tot gas-ul sau poate face reentrancy.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferențele dintre mecanisme și capcanele call. Greșeala tipică: a nu ști că un call către o adresă fără cod raportează succes.

50 Senior

Cum faci un smart contract upgradeable? Compară proxy-ul Transparent cu UUPS.

Răspuns scurt: Folosești un proxy care ține storage-ul și trimite apelurile prin delegatecall către o implementare înlocuibilă. La Transparent, logica de upgrade stă în proxy, accesibilă doar adminului; la UUPS stă în implementare, iar proxy-ul e mai mic și mai ieftin.

Contractele sunt imutabile, dar un proxy poate schimba adresa implementării la care trimite apelurile. Adresa implementării se păstrează într-un slot standardizat de ERC-1967, ales pseudoaleator ca să nu se suprapună cu variabilele aplicației.

Transparent proxy:

  • proxy-ul conține funcția de upgrade; adminul (în OpenZeppelin v5, un contract ProxyAdmin creat automat) poate face doar upgrade, iar ceilalți utilizatori ajung mereu la implementare;
  • evită conflictele de selectori între proxy și implementare;
  • costă puțin mai mult la fiecare apel, pentru verificarea apelantului.

UUPS (ERC-1822):

  • proxy-ul este minimal, iar funcția upgradeToAndCall vine din implementare (UUPSUpgradeable);
  • trebuie să suprascrii _authorizeUpgrade cu controlul de acces potrivit;
  • risc: dacă faci upgrade la o implementare fără logica de upgrade, contractul nu mai poate fi actualizat niciodată.

Reguli valabile pentru ambele:

  • fără constructor pentru stare; folosești initialize cu modifier-ul initializer, iar în constructorul implementării apelezi _disableInitializers();
  • nu schimbi ordinea și tipul variabilelor existente; adaugi doar la final sau folosești namespaced storage (ERC-7201, folosit de OpenZeppelin v5);
  • verifici compatibilitatea cu pluginul OpenZeppelin Upgrades pentru Hardhat sau Foundry.
SOLIDITY
contract BoxV1 is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    uint256 public value;
    constructor() { _disableInitializers(); }
    function initialize(address owner_) external initializer { __Ownable_init(owner_); }
    function _authorizeUpgrade(address) internal override onlyOwner {}
}

Decizia de business contează la fel de mult: cine poate face upgrade (ideal multisig și timelock) și dacă utilizatorii acceptă acest risc de încredere.

Ce urmărește intervievatorul: La senior se verifică înțelegerea compromisurilor și a riscurilor operaționale. Greșeala tipică: constructor în implementare sau _authorizeUpgrade lăsat fără control de acces.

51 Senior

Când ai folosi inline assembly (Yul) în Solidity și ce riscuri implică?

Răspuns scurt: Assembly se folosește rar: pentru optimizări de gas măsurabile în cod foarte des apelat, pentru operații pe care Solidity nu le expune direct sau pentru manipulare de memorie în biblioteci. Riscul este că pierzi verificările compilatorului: tipuri, overflow, gestiunea memoriei și lizibilitatea pentru auditori.

În blocurile assembly { ... } scrii Yul, un limbaj intermediar apropiat de opcode-uri. Exemple legitime:

  • citirea sau scrierea unor sloturi de storage specifice, cum fac proxy-urile cu sloturile ERC-1967;
  • propagarea exactă a datelor de revert dintr-un subapel;
  • biblioteci de nivel jos, optimizate și auditate, precum cele din OpenZeppelin sau Solady.
SOLIDITY
function _revertWith(bytes memory returndata) private pure {
    assembly ("memory-safe") {
        revert(add(returndata, 0x20), mload(returndata))
    }
}

Riscuri:

  • fără verificări aritmetice: add, sub, mul fac wrap-around;
  • memorie: Solidity folosește un „free memory pointer” la adresa 0x40. Dacă scrii peste memorie fără să-l respecți, poți corupe date folosite ulterior de cod Solidity. Adnotarea memory-safe îi spune compilatorului că respecți regulile, iar dacă minți, optimizer-ul poate genera cod greșit;
  • tipuri curățate: valorile din assembly nu sunt curățate automat; o adresă poate avea biți superiori „murdari” care trebuie mascați;
  • lizibilitate: auditorii și colegii au nevoie de mult mai mult timp, deci crește riscul ca o eroare să treacă neobservată.

Abordarea matură: scrii întâi în Solidity, măsori gas-ul, identifici punctele fierbinți și folosești assembly doar acolo unde câștigul este semnificativ și testat exhaustiv, de preferat cu fuzzing comparativ față de o implementare de referință în Solidity.

Ce urmărește intervievatorul: Se verifică judecata: când merită complexitatea și ce pierzi. Greșeala tipică la senior: entuziasm pentru assembly fără măsurători și fără teste diferențiale.

Standarde ERC și tokenuri

52 Junior

Ce este standardul ERC-20 și ce funcții și events definește?

Răspuns scurt: ERC-20 este interfața standard pentru tokenuri fungibile pe Ethereum. Definește totalSupply, balanceOf, transfer, approve, allowance, transferFrom și events Transfer și Approval, plus opționalele name, symbol și decimals.

Standardul (EIP-20) este o convenție: dacă un contract respectă interfața, orice wallet, exchange descentralizat sau aplicație poate lucra cu el fără cod special.

SOLIDITY
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

Puncte importante:

  • decimals este doar o convenție de afișare. Contractul lucrează cu unități întregi; un token cu 18 zecimale reprezintă „1 token” ca 10 ** 18. Există tokenuri cu 6 zecimale, deci nu presupune niciodată 18;
  • mint și burn nu fac parte din interfață; se semnalează prin Transfer de la sau către address(0);
  • soldurile se află în storage-ul contractului tokenului, nu „în wallet”;
  • funcțiile întorc bool, dar unele tokenuri reale nu întorc nimic sau întorc false în loc de revert, motiv pentru care se folosește SafeERC20.

Pentru implementare se folosește aproape întotdeauna ERC20 din OpenZeppelin, nu cod scris de la zero, pentru că detaliile (events, cazuri limită, hook-uri) sunt deja testate și auditate.

Ce urmărește intervievatorul: Se verifică dacă știi interfața și convențiile din jurul ei. Greșeala tipică: a presupune 18 zecimale sau a crede că mint/burn au funcții standard.

53 Junior

Explică fluxul approve și transferFrom. De ce nu poate un contract să-ți ia tokenurile direct?

Răspuns scurt: Un contract nu poate muta tokenurile tale pentru că doar msg.sender își poate transfera propriul sold. Prin approve(spender, amount) îi dai unui contract o alocare, iar acesta apelează transferFrom(tu, destinatar, sumă) în limita alocării.

Când trimiți ETH unui contract, valoarea vine odată cu apelul (msg.value). Tokenurile ERC-20 nu funcționează așa: ele sunt intrări într-o mapare din contractul tokenului. Un exchange descentralizat nu are cum să știe că ai „trimis” tokenuri dacă tu doar apelezi transfer, și nu poate reacționa în aceeași tranzacție.

De aceea fluxul are doi pași:

  • tranzacția 1: token.approve(dex, 100e18), care setează allowance[tu][dex] = 100e18;
  • tranzacția 2: dex.swap(...), iar în interior DEX-ul apelează token.transferFrom(tu, dex, 100e18). Contractul tokenului verifică alocarea, o scade și mută soldul.
SOLIDITY
function deposit(uint256 amount) external {
    // utilizatorul a apelat anterior token.approve(address(this), amount)
    token.safeTransferFrom(msg.sender, address(this), amount);
    deposits[msg.sender] += amount;
}

Riscuri de cunoscut:

  • aprobările nelimitate (type(uint256).max) sunt comode pentru utilizator, dar dacă acel contract are o vulnerabilitate sau este malițios, poate goli tot soldul de token, oricând;
  • aprobările rămân active până le revoci explicit;
  • un site fals poate cere o aprobare către o adresă controlată de atacator, una dintre cele mai frecvente fraude.

Alternative care reduc pașii: permit (EIP-2612), unde aprobarea se face printr-o semnătură off-chain, sau sisteme precum Permit2. Ca developer, cere doar suma necesară și afișează clar utilizatorului ce aprobă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce există alocările și riscurile lor. Greșeala tipică: a nu ști că aprobarea rămâne validă după tranzacție.

54 Junior

Care sunt diferențele dintre ERC-721 și ERC-1155?

Răspuns scurt: ERC-721 definește tokenuri non-fungibile, fiecare tokenId fiind unic și având un singur proprietar. ERC-1155 este multi-token: un singur contract gestionează mai multe ID-uri, fiecare cu propriul sold, deci poate reprezenta atât tokenuri fungibile, cât și unice, cu transferuri în lot.

ERC-721:

  • ownerOf(tokenId) întoarce proprietarul unic;
  • balanceOf(owner) numără câte NFT-uri are;
  • approve(to, tokenId) pentru un singur token și setApprovalForAll(operator, true) pentru toate;
  • transferFrom și safeTransferFrom; varianta „safe” verifică dacă destinatarul contract poate primi NFT-uri;
  • metadata opțională prin tokenURI(tokenId).

ERC-1155:

  • balanceOf(account, id): ai un sold pentru fiecare ID;
  • un ID cu oferta 1 se comportă ca un NFT, unul cu oferta 1000 ca un token fungibil (de exemplu un obiect de joc);
  • safeBatchTransferFrom mută mai multe ID-uri și cantități într-o singură tranzacție, deci economisește gas;
  • există doar setApprovalForAll, nu aprobare per token;
  • transferurile sunt întotdeauna „safe”: destinatarii contract trebuie să implementeze onERC1155Received;
  • metadata prin uri(id), de obicei un șablon cu {id}.

Când alegi:

  • colecții de artă sau certificate unice, unde fiecare obiect are identitate și istoric propriu: ERC-721;
  • jocuri, bilete cu mai multe categorii, colecții cu multe copii identice: ERC-1155.

Ambele standarde implementează ERC-165 (supportsInterface), ca alte contracte să poată detecta ce interfață suportă. Pentru implementare, folosește contractele OpenZeppelin și extensiile lor (ERC721Enumerable, ERC721URIStorage, ERC1155Supply).

Ce urmărește intervievatorul: Se verifică dacă știi să alegi standardul potrivit pentru un caz real. Greșeala tipică: a descrie ERC-1155 doar ca „NFT mai ieftin”, fără a înțelege modelul de solduri pe ID.

55 Junior

Unde se păstrează imaginea și datele unui NFT și ce înseamnă tokenURI?

Răspuns scurt: De obicei, contractul păstrează doar un tokenURI care indică un fișier JSON cu metadata (nume, descriere, link spre imagine, atribute). Fișierele stau off-chain, ideal pe stocare adresată prin conținut, precum IPFS sau Arweave, nu pe un server obișnuit.

Stocarea unei imagini direct on-chain este foarte scumpă, așa că standardul ERC-721 definește extensia de metadata: tokenURI(tokenId) întoarce un URI către un JSON de forma:

JSON
{
  "name": "Insigna #12",
  "description": "Certificat de absolvire",
  "image": "ipfs://bafy.../12.png",
  "attributes": [{ "trait_type": "Nivel", "value": "Mid" }]
}

Variante de stocare:

  • server HTTP propriu: simplu, dar proprietarul serverului poate schimba sau șterge conținutul, iar NFT-ul ajunge să indice nimic;
  • IPFS: adresa (CID) este derivată din conținut, deci fișierul nu poate fi modificat fără să se schimbe adresa. Fișierul trebuie însă „ținut” (pinned) de cineva, altfel poate deveni indisponibil;
  • Arweave: stocare permanentă plătită o singură dată;
  • on-chain: SVG generat sau codificat în contract și returnat ca data: URI. Complet descentralizat, dar scump și limitat.
SOLIDITY
function tokenURI(uint256 id) public view override returns (string memory) {
    _requireOwned(id);                 // OpenZeppelin v5
    return string.concat(_baseURI(), Strings.toString(id), ".json");
}

Întrebări pe care să le pui într-un proiect real: poate cineva schimba baseURI după lansare? Există un event (EIP-4906, MetadataUpdate) ca marketplace-urile să reîmprospăteze datele? Există un mecanism de reveal și este corect față de cumpărători? Aceste detalii arată că înțelegi că proprietatea NFT-ului și conținutul lui sunt lucruri diferite.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce este de fapt on-chain într-un NFT. Greșeala tipică: a crede că imaginea este stocată în blockchain în mod implicit.

56 Mid

Ce problemă are approve atunci când schimbi o alocare existentă și cum se evită?

Răspuns scurt: Dacă schimbi alocarea de la N la M cu approve, spender-ul poate vedea tranzacția în mempool, cheltui întâi N și apoi M. Se evită trecând întâi prin 0, prin ajustări relative sau prin aprobări exacte, de scurtă durată.

Scenariul: ai aprobat 100 de tokenuri pentru Bob. Vrei să reduci la 50 și trimiți approve(bob, 50). Bob vede tranzacția în mempool și trimite cu prioritate mai mare transferFrom(tu, bob, 100). Prima intră tranzacția lui Bob, apoi a ta setează alocarea la 50, pe care Bob o folosește și pe aceasta. Total: 150, deși intenția ta a fost maximum 100.

Atenuări:

  • treci întâi alocarea la 0, aștepți confirmarea, apoi setezi noua valoare. Unele tokenuri, precum USDT pe Ethereum, chiar cer asta: refuză approve de la o valoare nenulă la alta nenulă;
  • funcții relative de tip increaseAllowance / decreaseAllowance. Atenție: OpenZeppelin v5 le-a eliminat din ERC20, considerând că nu rezolvă problema de fond; pentru tokenuri externe, SafeERC20 oferă safeIncreaseAllowance, safeDecreaseAllowance și forceApprove;
  • aprobări exacte pentru suma unei singure operații, consumate imediat în aceeași interacțiune;
  • permit (EIP-2612) cu termen de expirare.
SOLIDITY
using SafeERC20 for IERC20;
// setează alocarea corect chiar și pentru tokenuri care cer trecerea prin 0
IERC20(token).forceApprove(router, amount);

În practică, riscul cel mai mare nu este această cursă, ci aprobările nelimitate lăsate active pentru contracte vulnerabile. Un răspuns bun le menționează pe amândouă și explică ce ai face în UI pentru utilizator.

Ce urmărește intervievatorul: Se verifică dacă cunoști atacul clasic și cum s-au schimbat recomandările (inclusiv OpenZeppelin v5). Greșeala tipică: a recomanda increaseAllowance ca parte din ERC-20 standard.

57 Mid

Ce este permit (EIP-2612) și ce avantaje și riscuri aduce?

Răspuns scurt: permit permite unui deținător de tokenuri să aprobe o alocare printr-o semnătură EIP-712 off-chain, pe care oricine o poate trimite on-chain. Elimină tranzacția separată de approve, dar semnăturile pot fi folosite abuziv dacă utilizatorul semnează fără să înțeleagă.

Funcția are forma:

SOLIDITY
function permit(
    address owner, address spender, uint256 value,
    uint256 deadline, uint8 v, bytes32 r, bytes32 s
) external;

Tokenul verifică semnătura EIP-712 a lui owner peste (owner, spender, value, nonce, deadline), crește nonce-ul și setează alocarea. Avantaje:

  • utilizatorul face o singură tranzacție (de exemplu un depozit), care include și permit;
  • tranzacția poate fi trimisă de un relayer, deci utilizatorul nu are nevoie de ETH pentru gas la aprobare;
  • termenul deadline limitează valabilitatea.
SOLIDITY
function depositWithPermit(uint256 amt, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
    try IERC20Permit(address(token)).permit(msg.sender, address(this), amt, deadline, v, r, s) {} catch {}
    token.safeTransferFrom(msg.sender, address(this), amt);
}

try/catch în jurul permit este intenționat: cineva care vede semnătura în mempool o poate trimite primul (front-running), iar a doua încercare ar da revert pentru că nonce-ul a fost deja folosit. Alocarea există totuși, deci transferFrom reușește.

Riscuri:

  • semnăturile de tip permit sunt o țintă des întâlnită pentru phishing: utilizatorul semnează un mesaj care pare inofensiv, iar atacatorul obține alocarea fără nicio tranzacție vizibilă din partea victimei;
  • nu toate tokenurile au permit, iar unele au variante nestandard (DAI are altă semnătură);
  • unele tokenuri au o funcție fallback care nu dă revert, deci un apel permit „reușește” fără efect. Verifică alocarea rezultată, nu doar lipsa erorii.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi mecanismul și cazurile limită reale. Greșeala tipică: apelul permit fără try/catch, ceea ce permite unui atacator să blocheze tranzacția prin front-running.

58 Mid

De ce există safeTransferFrom la ERC-721 și ce face onERC721Received?

Răspuns scurt: safeTransferFrom verifică dacă destinatarul este un contract și, în acest caz, îi apelează onERC721Received, care trebuie să întoarcă selectorul ei. Previne blocarea NFT-urilor în contracte care nu știu să le gestioneze, dar deschide o cale de reentrancy.

Problema: dacă trimiți un NFT cu transferFrom către un contract care nu are nicio funcție de transfer mai departe, NFT-ul rămâne blocat pentru totdeauna. safeTransferFrom rezolvă asta: după mutarea tokenului, dacă destinatarul are cod, apelează

SOLIDITY
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data)
    external returns (bytes4);

și cere ca rezultatul să fie IERC721Receiver.onERC721Received.selector. Altfel, transferul dă revert. EOA-urile nu sunt verificate.

SOLIDITY
contract Staking is IERC721Receiver {
    function onERC721Received(address, address from, uint256 id, bytes calldata)
        external override returns (bytes4)
    {
        require(msg.sender == address(nft), "doar colectia acceptata");
        stakedBy[id] = from;
        return IERC721Receiver.onERC721Received.selector;
    }
}

Lucruri de reținut:

  • verifică msg.sender: oricine poate apela direct onERC721Received cu date false, deci trebuie să accepți doar apeluri de la colecția așteptată;
  • reentrancy: _safeMint și safeTransferFrom apelează cod extern. Un contract de mint care actualizează contorul după _safeMint poate fi reapelat din onERC721Received și poate depăși limita de mint per utilizator. Aplică Checks-Effects-Interactions și nonReentrant;
  • la ERC-1155, toate transferurile sunt „safe”, cu onERC1155Received și onERC1155BatchReceived;
  • tokenurile ERC-20 nu au un asemenea mecanism, motiv pentru care s-au pierdut multe tokenuri trimise din greșeală la adresele contractelor.

Ce urmărește intervievatorul: Se verifică dacă știi scopul mecanismului și riscul de reentrancy pe care îl introduce. Greșeala tipică: a trata _safeMint ca operație fără apeluri externe.

59 Mid

Scrie un token ERC-20 cu OpenZeppelin, în care doar proprietarul poate emite tokenuri noi și oferta are un plafon.

Răspuns scurt: Moștenești ERC20, ERC20Capped și Ownable din OpenZeppelin v5, transmiți numele, simbolul, plafonul și proprietarul în constructor și expui o funcție mint protejată de onlyOwner. Plafonul este impus automat la fiecare emitere.

Implementare pentru OpenZeppelin Contracts v5.x:

SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Capped} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

contract AcademyToken is ERC20Capped, Ownable {
    constructor(address initialOwner)
        ERC20("Academy Token", "ACAD")
        ERC20Capped(1_000_000 * 10 ** 18)
        Ownable(initialOwner)
    {}

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

Explicații:

  • în v5, Ownable primește proprietarul inițial în constructor; în v4 era implicit msg.sender;
  • ERC20Capped suprascrie hook-ul intern _update și dă revert cu ERC20ExceededCap dacă emiterea ar depăși plafonul. Pentru că ERC20Capped moștenește deja ERC20, ajunge să-l listezi pe el;
  • decimals() este implicit 18; dacă vrei altă valoare, o suprascrii;
  • _mint emite Transfer(address(0), to, amount).

Ce ar mai întreba intervievatorul:

  • cum ai transfera proprietatea către un multisig (transferOwnership, sau Ownable2Step pentru transfer în doi pași);
  • cum ai permite mai multor adrese să emită, folosind AccessControl cu un MINTER_ROLE;
  • ce teste ai scrie: emitere de către non-proprietar (revert), depășirea plafonului (revert), events emise corect.

Faptul că folosești o bibliotecă auditată în loc să rescrii ERC-20 este un semnal pozitiv la interviu.

Ce urmărește intervievatorul: Este o întrebare de codare care verifică familiaritatea cu OpenZeppelin și diferențele de versiune. Greșeala tipică: a folosi sintaxa v4 (Ownable() fără argument) cu v5.

60 Senior

Ce tokenuri ERC-20 nestandard pot strica un protocol și cum te protejezi?

Răspuns scurt: Probleme frecvente: tokenuri care nu întorc bool (USDT pe Ethereum), cu taxă la transfer, rebase, cu hook-uri (ERC-777), cu liste negre sau zecimale neobișnuite. Te protejezi cu SafeERC20, măsurând soldul real primit și limitând explicit tokenurile acceptate.

Un protocol care acceptă „orice ERC-20” face, de fapt, presupuneri pe care unele tokenuri nu le respectă.

  • Fără valoare returnată sau false în loc de revert: require(token.transfer(...)) eșuează la decodare pentru tokenurile care nu întorc nimic, iar fără verificare ratezi eșecurile semnalate prin false. Soluția: SafeERC20.safeTransfer, care tratează ambele cazuri.
  • Taxă la transfer: trimiți 100, contractul primește 98. Dacă îi creditezi utilizatorului 100, contabilitatea ta devine insolvabilă.
  • Rebasing: soldurile se modifică fără transferuri, deci un sold salvat în contract devine incorect.
  • Hook-uri (ERC-777 sau implementări custom): transferul apelează cod al utilizatorului, ceea ce deschide reentrancy chiar și într-o funcție aparent sigură.
  • Liste negre și pauză: un transfer către o anumită adresă poate fi blocat de emitent, ceea ce poate bloca o coadă de plăți.
  • Zecimale: 6, 8 sau chiar 2. Calculele de preț trebuie normalizate.
SOLIDITY
uint256 before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), amount);
uint256 received = token.balanceOf(address(this)) - before;
deposits[msg.sender] += received; // creditezi ce a sosit efectiv

Strategie la nivel de arhitectură: decizi explicit ce tipuri de tokenuri suporți, documentezi asta, folosești o listă albă dacă e posibil și scrii teste cu mock-uri pentru fiecare comportament ciudat. Mulți auditori încep revizia întrebând exact ce tokenuri vor fi acceptate.

Ce urmărește intervievatorul: La senior se verifică experiența cu cazurile reale care au produs pierderi. Greșeala tipică: creditarea sumei cerute în loc de suma efectiv primită.

Securitatea smart contractelor

61 Junior

Ce este un atac de tip reentrancy? Dă un exemplu.

Răspuns scurt: Reentrancy apare când un contract face un apel extern înainte să-și actualizeze starea, iar contractul apelat reintră în funcție și exploatează starea veche. Exemplul clasic este o funcție de retragere care trimite ETH înainte să pună soldul la zero.

Codul vulnerabil:

SOLIDITY
contract Bank {
    mapping(address => uint256) public balances;

    function deposit() external payable { balances[msg.sender] += msg.value; }

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        (bool ok, ) = msg.sender.call{value: amount}(""); // interacțiune
        require(ok);
        balances[msg.sender] = 0;                          // efect, prea târziu
    }
}

Atacatorul:

SOLIDITY
contract Attacker {
    Bank bank;
    constructor(Bank b) { bank = b; }
    function attack() external payable { bank.deposit{value: msg.value}(); bank.withdraw(); }
    receive() external payable {
        if (address(bank).balance >= msg.value) bank.withdraw(); // reintră
    }
}

La fiecare primire de ETH, receive apelează din nou withdraw. Soldul atacatorului este încă cel inițial, deci banca plătește din nou, până se golește. Abia la final se execută linia care pune soldul la zero.

Acest tip de bug a stat la baza incidentului The DAO din 2016, care a dus la hard fork-ul Ethereum / Ethereum Classic.

Soluții:

  • Checks-Effects-Interactions: pune soldul la zero înainte de call;
  • ReentrancyGuard (nonReentrant) ca a doua barieră;
  • modelul pull pentru plăți.

Reentrancy nu apare doar la ETH: orice apel extern este un punct de risc, inclusiv tokenuri cu hook-uri, safeTransferFrom pentru NFT-uri sau apeluri către contracte de tip callback.

Ce urmărește intervievatorul: Este probabil cea mai frecventă întrebare de securitate la interviu. Se verifică dacă poți scrie atât codul vulnerabil, cât și atacul, nu doar defini conceptul.

62 Junior

Ce este tiparul Checks-Effects-Interactions?

Răspuns scurt: Checks-Effects-Interactions este o ordine a operațiilor într-o funcție: întâi verifici condițiile, apoi modifici starea contractului, iar abia la final faci apeluri externe. Astfel, dacă apelul extern reintră în contract, găsește deja starea actualizată.

Cele trei etape:

  • Checks: require-uri sau erori custom pentru permisiuni, solduri, parametri, termene;
  • Effects: toate scrierile în storage și events: scazi soldul, marchezi revendicarea, incrementezi nonce-ul;
  • Interactions: transferuri de ETH, apeluri către alte contracte, transferuri de tokenuri.
SOLIDITY
function claimReward() external {
    // Checks
    uint256 reward = rewards[msg.sender];
    if (reward == 0) revert NothingToClaim();

    // Effects
    rewards[msg.sender] = 0;
    totalClaimed += reward;
    emit Claimed(msg.sender, reward);

    // Interactions
    rewardToken.safeTransfer(msg.sender, reward);
}

De ce funcționează: vulnerabilitatea de reentrancy cere ca, în momentul apelului extern, contractul să fie într-o stare intermediară inconsecventă. Dacă toate efectele sunt deja aplicate, o reintrare nu mai găsește nimic de exploatat în acea funcție.

Limitări de cunoscut:

  • uneori ai nevoie de rezultatul apelului extern ca să decizi starea, de exemplu suma efectiv primită de la un token cu taxă. Atunci combini tiparul cu nonReentrant;
  • protejează o funcție, dar nu întotdeauna întregul contract: o reintrare într-o altă funcție care citește o stare încă neactualizată (cross-function reentrancy) rămâne posibilă dacă efectele nu sunt complete;
  • funcțiile view apelate de alte protocoale în timpul unei reintrări pot întoarce valori temporar greșite (read-only reentrancy).

Tiparul este o regulă de bază pe care orice reviewer o verifică primul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă aplici tiparul automat și dacă îi cunoști limitele. Greșeala tipică: a emite events sau a actualiza contoare după transfer.

63 Junior

Cum implementezi controlul accesului într-un contract și ce greșeli apar des?

Răspuns scurt: Pentru un singur administrator folosești Ownable sau Ownable2Step, iar pentru mai multe roluri AccessControl din OpenZeppelin. Greșelile frecvente sunt funcțiile sensibile lăsate publice, funcțiile de inițializare neprotejate, rolurile prea largi și cheile administrative ținute într-un singur EOA.

Variante:

  • Ownable: un proprietar, modifier-ul onlyOwner. Simplu, potrivit pentru contracte mici;
  • Ownable2Step: noul proprietar trebuie să apeleze acceptOwnership, deci o greșeală de tastare nu pierde controlul;
  • AccessControl: roluri identificate prin bytes32, fiecare cu un rol administrator. Separi responsabilitățile: MINTER_ROLE, PAUSER_ROLE, UPGRADER_ROLE.
SOLIDITY
contract Treasury is AccessControl {
    bytes32 public constant PAYER_ROLE = keccak256("PAYER_ROLE");

    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
    }

    function pay(address to, uint256 amount) external onlyRole(PAYER_ROLE) {
        // ...
    }
}

Greșeli frecvente găsite în audituri:

  • o funcție setPrice, setOracle sau mint declarată external fără niciun modifier;
  • initialize care poate fi apelată de oricine, sau de două ori;
  • o funcție internal care devine accesibilă public după un refactoring;
  • un singur rol administrator pentru tot, controlat de o cheie privată ținută pe laptopul unui developer;
  • verificarea făcută pe tx.origin în loc de msg.sender;
  • lipsa unui event la schimbarea rolurilor sau a parametrilor.

Pentru producție: rolurile importante merg la un multisig (de exemplu Safe), schimbările sensibile trec printr-un timelock, iar testele includ cazul „apelant fără rol” pentru fiecare funcție protejată.

Ce urmărește intervievatorul: Se verifică dacă știi uneltele standard și cum se ajunge practic la vulnerabilități de acces. Greșeala tipică: a uita de funcțiile de inițializare și de administrare operațională a cheilor.

64 Junior

Ce este front-running-ul în contextul blockchain?

Răspuns scurt: Front-running-ul înseamnă că cineva vede tranzacția ta în mempool și o trimite pe a sa înaintea ta, de obicei cu fee mai mare, ca să profite de informația din ea. Este posibil pentru că mempool-ul e public, iar ordinea o decide producătorul blocului.

Exemple concrete:

  • swap pe un DEX: un bot vede că vei cumpăra mult dintr-un token, cumpără înaintea ta (prețul crește), iar după tranzacția ta vinde. Aceasta este o sandwich attack;
  • recompense pentru primul: un contract plătește prima persoană care trimite răspunsul corect la o ghicitoare. Botul copiază răspunsul tău și îl trimite cu prioritate mai mare;
  • revendicări de semnături: cineva trimite înaintea ta o semnătură permit sau un voucher pe care tu urma să-l folosești, ca să-ți blocheze tranzacția;
  • inițializări: un contract deployat fără să fie inițializat în aceeași tranzacție poate fi inițializat de altcineva.

Termenul mai larg este MEV (maximal extractable value): profitul care se poate obține prin includerea, excluderea sau reordonarea tranzacțiilor dintr-un bloc. Există bots specializați și builderi care fac asta în mod sistematic.

De ce contează la interviu: un developer trebuie să presupună că orice informație dintr-o tranzacție este publică înainte de execuție și că ordinea nu este garantată. De aceea proiectezi contractele astfel încât ordinea să nu poată fi exploatată:

  • limite de slippage și termene la swap-uri;
  • commit-reveal pentru valori secrete;
  • legarea datelor semnate de msg.sender;
  • inițializare atomică la deploy.

Front-running-ul nu este un bug în EVM, ci o consecință a transparenței și a modului în care se construiesc blocurile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de unde vine problema și o poți recunoaște în exemple. Greșeala tipică: a crede că tranzacțiile sunt procesate strict în ordinea trimiterii.

65 Junior

De ce nu poți genera în siguranță numere aleatoare cu block.timestamp sau blockhash? Ce folosești în schimb?

Răspuns scurt: Valorile din bloc sunt cunoscute sau influențabile de producătorul blocului și pot fi calculate de orice contract din aceeași tranzacție, deci rezultatul poate fi prezis sau manipulat. Pentru aleatoriu cu miză folosești un oracol verificabil, precum Chainlink VRF, sau o schemă commit-reveal.

Exemplu vulnerabil:

SOLIDITY
function play() external payable {
    uint256 r = uint256(keccak256(abi.encode(block.timestamp, block.prevrandao, msg.sender)));
    if (r % 2 == 0) payable(msg.sender).transfer(2 * msg.value);
}

Probleme:

  • un contract atacator poate calcula exact aceeași valoare în aceeași tranzacție, înainte să apeleze play, și apelează doar când câștigă;
  • block.timestamp este ales de propunător, în limitele regulilor protocolului;
  • block.prevrandao (fostul difficulty după The Merge) vine din RANDAO. Propunătorul poate influența rezultatul alegând să nu publice blocul, renunțând la recompensă, ceea ce merită dacă miza e mare;
  • blockhash funcționează doar pentru ultimele 256 de blocuri, iar pentru blocul curent întoarce 0.

Soluții:

  • Chainlink VRF: ceri un număr aleator, oracolul îl livrează într-o tranzacție ulterioară, împreună cu o dovadă criptografică pe care contractul o verifică. Necesită plată pentru serviciu și un flux în doi pași (cerere, apoi callback);
  • commit-reveal între participanți, cu depozite care penalizează abandonul;
  • pentru valori fără miză (de exemplu o culoare decorativă), sursele din bloc pot fi acceptabile, dar trebuie să documentezi alegerea.

Indiferent de soluție, logica trebuie să fie în doi pași: nimeni nu trebuie să poată afla rezultatul înainte ca acțiunea lui să devină irevocabilă.

Ce urmărește intervievatorul: Se verifică dacă știi de ce determinismul EVM face aleatoriul dificil. Greșeala tipică: a crede că hash-uirea mai multor variabile din bloc face rezultatul imprevizibil.

66 Mid

Ce protecție oferă ReentrancyGuard și ce forme de reentrancy nu acoperă complet?

Răspuns scurt: nonReentrant folosește un flag în storage (sau transient storage) care împiedică reintrarea în orice funcție marcată din același contract cât timp una rulează. Nu acoperă funcțiile nemarcate, reintrarea între contracte diferite care împart starea și read-only reentrancy prin funcții view.

Implementarea este simplă: la intrare verifici că flag-ul este „neintrat”, îl setezi „intrat”, rulezi funcția și îl resetezi. Orice apel imbricat către o funcție nonReentrant dă revert. OpenZeppelin oferă și ReentrancyGuardTransient, care folosește TSTORE/TLOAD (EIP-1153, rețele de la Cancun) și este mai ieftin.

Forme care scapă:

  • cross-function: withdraw este protejată, dar transfer nu. În timpul apelului extern din withdraw, atacatorul apelează transfer și mută un sold care nu a fost încă scăzut. Soluția: CEI în toate funcțiile și guard pe toate funcțiile care modifică starea sensibilă;
  • cross-contract: două contracte ale aceluiași protocol (de exemplu un vault și un modul de recompense) au fiecare propriul guard, dar împart starea logică. Reintrarea dintr-unul în celălalt nu este blocată;
  • read-only reentrancy: în timpul unui apel extern, un view precum getPrice() întoarce o valoare calculată dintr-o stare temporar inconsecventă. Alt protocol care folosește acea valoare ca preț poate fi exploatat. Guard-ul nu se aplică funcțiilor view, dar poți expune o verificare precum _reentrancyGuardEntered() sau poți actualiza toată starea înainte de apel.
SOLIDITY
function getPrice() external view returns (uint256) {
    if (_reentrancyGuardEntered()) revert ReentrantRead();
    return totalAssets() * 1e18 / totalSupply();
}

Concluzie: guard-ul este o plasă de siguranță, nu un substitut pentru ordinea corectă a operațiilor și pentru o hartă clară a tuturor apelurilor externe.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele uneltei, nu doar existența ei. Greșeala tipică: a crede că nonReentrant pe o singură funcție protejează tot protocolul.

67 Mid

Ce este un atac de tip denial of service (DoS) într-un smart contract? Dă exemple.

Răspuns scurt: Un DoS face o funcție sau un contract imposibil de folosit, fără ca atacatorul să fure neapărat fonduri. Exemple: bucle peste liste nelimitate care depășesc limita de gas, plăți push către un destinatar care refuză ETH, dependența de un apel extern care poate eșua.

Exemple:

  • Bucle nelimitate: o funcție distribute() care iterează peste toți participanții. Când lista devine suficient de mare, tranzacția depășește limita de gas a blocului și nu mai poate fi executată. Dacă atacatorul poate adăuga intrări ieftine, poate grăbi asta.
  • Destinatar care refuză plata: un contract de licitație returnează automat ETH ofertantului depășit. Atacatorul licitează dintr-un contract al cărui receive dă mereu revert. Orice ofertă nouă eșuează, iar atacatorul rămâne câștigător.
SOLIDITY
// vulnerabil
function bid() external payable {
    require(msg.value > highest);
    payable(highestBidder).transfer(highest); // poate da revert mereu
    highestBidder = msg.sender;
    highest = msg.value;
}
  • Dependență externă: o funcție critică apelează un oracol sau un token care poate fi pus pe pauză sau poate bloca o adresă.
  • Griefing: cineva trimite o sumă minusculă care strică o condiție de egalitate strictă, de exemplu require(address(this).balance == expected).

Soluții:

  • modelul pull: păstrezi sumele de returnat într-o mapare și fiecare utilizator le retrage singur;
  • procesare în loturi, cu index de continuare, sau mutarea calculelor off-chain cu verificare on-chain (Merkle proofs);
  • evitarea egalităților stricte cu solduri;
  • tratarea eșecurilor externe cu try/catch acolo unde un eșec nu trebuie să blocheze tot.

În review, caută fiecare buclă și fiecare apel extern și întreabă: ce se întâmplă dacă lista are un milion de elemente sau dacă apelul eșuează mereu?

Ce urmărește intervievatorul: Se verifică dacă recunoști tiparele de DoS și știi soluția pull. Greșeala tipică: plăți automate către mai mulți destinatari într-o singură tranzacție.

68 Mid

Ce înseamnă manipularea de oracol (oracle manipulation) și cum o previi?

Răspuns scurt: Atacatorul mută sursa de preț citită de protocol, de obicei rezervele unui pool DEX, adesea cu un flash loan, ca protocolul să decidă pe un preț fals. O previi cu oracole agregate (de exemplu Chainlink) sau TWAP, plus verificări de validitate.

Scenariu tipic: un protocol de împrumut calculează valoarea garanției citind prețul spot dintr-un pool reserveB / reserveA.

  • atacatorul ia un flash loan: un împrumut fără garanție care trebuie returnat în aceeași tranzacție;
  • face un swap uriaș în pool, care deformează prețul;
  • folosește prețul umflat ca să împrumute mult mai mult decât valorează garanția;
  • inversează swap-ul, returnează flash loan-ul și păstrează diferența.

Totul se întâmplă într-o singură tranzacție, deci nu există risc de piață pentru atacator. Flash loan-urile nu sunt vulnerabilitatea în sine; ele doar elimină nevoia de capital propriu.

Prevenire:

  • oracole off-chain agregate (de exemplu Chainlink Data Feeds): prețul vine de la mai mulți operatori și surse;
  • TWAP: media prețului pe o fereastră de timp, mult mai scumpă de manipulat decât prețul spot dintr-un singur bloc;
  • verificări la citire: actualitatea datelor, valori nenule, abateri față de o a doua sursă.
SOLIDITY
(, int256 answer, , uint256 updatedAt, ) = feed.latestRoundData();
if (answer <= 0) revert BadPrice();
if (block.timestamp - updatedAt > MAX_DELAY) revert StalePrice();

Atenție și la alte surse manipulabile: balanceOf(address(this)) folosit ca preț al unui share (atac prin donație), rate de schimb ale vault-urilor ERC-4626 imediat după deploy, sau oracole cu un singur operator. La auditul unui protocol DeFi, prima întrebare este: de unde vine fiecare preț și cât costă să-l muți?

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul economic al atacurilor DeFi. Greșeala tipică: a da vina pe flash loan-uri în loc de folosirea prețului spot.

69 Mid

Cum protejezi utilizatorii unui contract de swap de front-running și sandwich attacks?

Răspuns scurt: Principala protecție este parametrul de slippage, adică suma minimă acceptată la ieșire, plus un deadline după care tranzacția nu mai este validă. Complementar, utilizatorii pot trimite tranzacțiile prin RPC-uri private, iar protocolul poate folosi licitații în loturi sau mecanisme bazate pe intenții.

Într-un sandwich, botul cumpără înaintea ta, tu cumperi la un preț mai prost, iar botul vinde după tine. Câștigul lui este diferența de preț pe care ai acceptat-o fără să știi.

Slippage (amountOutMin): utilizatorul declară câți tokeni acceptă minim. Dacă prețul a fost mutat peste toleranță, tranzacția dă revert, iar sandwich-ul nu mai este profitabil.

SOLIDITY
function swapExactIn(uint256 amountIn, uint256 amountOutMin, uint256 deadline) external {
    if (block.timestamp > deadline) revert Expired();
    uint256 out = _quote(amountIn);
    if (out < amountOutMin) revert Slippage(out, amountOutMin);
    // efectuează swap-ul
}

Detalii care contează:

  • amountOutMin trebuie calculat off-chain, din cotația curentă minus toleranța. Dacă îl calculezi on-chain în aceeași tranzacție, el se mută odată cu prețul manipulat și nu protejează nimic;
  • o valoare 0 pentru amountOutMin, uneori lăsată în scripturi sau integrări, înseamnă protecție zero;
  • deadline previne execuția tranzacției mult mai târziu, la un preț complet diferit, dacă a rămas blocată în mempool.

Alte straturi:

  • RPC-uri private sau protecție MEV: tranzacția ajunge direct la builderi, fără să fie expusă în mempool-ul public;
  • licitații în loturi sau sisteme bazate pe intenții: ordinele sunt grupate și executate la un preț uniform, deci ordinea în bloc contează mai puțin;
  • commit-reveal pentru acțiuni unde parametrii trebuie ascunși.

În UI, afișează clar toleranța și impactul de preț, cu valori implicite rezonabile.

Ce urmărește intervievatorul: Se verifică dacă știi aplica protecțiile corect. Greșeala tipică: calcularea amountOutMin on-chain sau setarea lui la zero în integrări.

70 Mid

Ce verifici, pe rând, când faci code review la un smart contract înainte de deploy?

Răspuns scurt: Verifici controlul accesului pe fiecare funcție externă, toate apelurile externe (reentrancy, valori returnate), aritmetica și conversiile, presupunerile despre tokenuri și oracole, buclele și riscul de DoS, inițializarea și upgrade-urile, events pentru schimbările importante și acoperirea testelor pentru cazurile limită.

O listă practică, în ordinea în care o aplic de obicei:

  • Context: ce face contractul, ce valori deține, cine îl folosește, ce tokenuri și oracole acceptă. Fără acest model, revizia este doar sintactică.
  • Suprafața externă: listezi toate funcțiile public/external care modifică starea. Pentru fiecare: cine o poate apela? Este intenționat?
  • Apeluri externe: unde se apelează alt cod (call, transferuri de tokenuri, safeMint, callback-uri)? Starea este actualizată înainte? Rezultatul este verificat?
  • Aritmetică: rotunjiri la împărțire (în favoarea protocolului), ordinea înmulțire-împărțire, blocuri unchecked, conversii cu trunchiere, zecimale diferite.
  • Presupuneri: tokenuri cu taxă, prețuri spot, address(this).balance, timestamp-uri.
  • DoS și gas: bucle nelimitate, plăți push, dependențe care pot eșua.
  • Inițializare și upgrade: initialize protejat și apelat atomic, layout de storage, cine poate face upgrade.
  • Administrare: ce poate face adminul, există timelock, există pauză, sunt events emise.
  • Teste: există teste negative, fuzzing pentru funcțiile matematice, invarianți pentru solduri?
  • Unelte: rulezi un analizor static precum Slither și cercetezi fiecare avertisment, nu doar cele marcate ca grave.
BASH
slither . --exclude-dependencies
forge test --fuzz-runs 10000
forge coverage

O regulă bună: notezi fiecare presupunere pe care codul o face și cauți intrarea prin care un atacator o poate încălca.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai un proces structurat, nu doar o listă de vulnerabilități memorate. Greșeala tipică: a începe direct cu detalii de sintaxă, fără a înțelege ce valori protejează contractul.

71 Senior

Cum ai aborda auditul de securitate al unui protocol nou, de la primire până la raport?

Răspuns scurt: Pornești de la documentație și modelul de amenințări, parcurgi manual fluxurile de bani și permisiuni, rulezi analiză statică, scrii fuzz și invarianți, construiești PoC-uri pentru suspiciuni, apoi raportezi constatările după impact și probabilitate, cu dovezi și recomandări.

Etapele unui audit serios:

  • Scoping: commit-ul exact, fișierele incluse, dependențele, rețelele țintă, tokenurile suportate. Fără un commit fix, raportul nu are sens.
  • Înțelegere: documentație, specificații, diagrame. Notezi actorii (utilizator, admin, keeper, oracol) și ce poate face fiecare. Definești invarianți: „suma soldurilor este egală cu totalul depus”, „nimeni nu poate retrage mai mult decât a depus plus dobânda”.
  • Analiză automată: Slither pentru tipare cunoscute, compilarea cu avertismente, eventual analiză simbolică (de exemplu Halmos sau Mythril) pentru funcții izolate.
  • Revizie manuală: urmărești fluxurile de valoare de la intrare la ieșire, fiecare apel extern, fiecare rotunjire, fiecare cale de administrare. Aici se găsesc de obicei problemele grave, care sunt erori de logică de business, nu tipare generice.
  • Testare ofensivă: fuzzing și invariant testing în Foundry sau Echidna, plus teste pe fork de mainnet cu tokenuri și oracole reale. Pentru fiecare suspiciune, scrii un proof of concept.
  • Raport: fiecare constatare cu severitate (impact și probabilitate), locație, scenariu, PoC, recomandare. Separi clar problemele critice de cele informative.
  • Verificarea corecturilor: revezi diff-ul de remediere, pentru că o corectură poate introduce o problemă nouă.

Un auditor matur spune și ce nu acoperă auditul: cod din afara scope-ului, riscurile operaționale ale cheilor, economia protocolului. Un audit reduce riscul, nu îl elimină.

Ce urmărește intervievatorul: La senior se verifică metodologia și onestitatea față de limitele unui audit. Greșeala tipică: a reduce auditul la rularea unor unelte automate.

72 Senior

Ce s-a schimbat la selfdestruct după EIP-6780 și de ce nu te poți baza pe address(this).balance?

Răspuns scurt: De la Cancun (martie 2024, EIP-6780), selfdestruct șterge codul și storage-ul doar în tranzacția în care a fost creat contractul; altfel doar trimite ETH-ul. ETH-ul poate fi oricum forțat într-un contract fără să i se execute codul, deci soldul nu reflectă exact depozitele.

Înainte de Cancun, selfdestruct(beneficiar) ștergea contractul și trimitea tot soldul beneficiarului. Asta a permis tipare periculoase: contracte „metamorfice”, combinate cu CREATE2, care puteau fi șterse și redeployate cu alt cod la aceeași adresă, sau proxy-uri distruse prin delegatecall către o implementare care execută selfdestruct.

EIP-6780 a restrâns comportamentul:

  • dacă selfdestruct rulează în aceeași tranzacție în care a fost creat contractul, efectul vechi se păstrează;
  • altfel, doar transferă soldul de ETH, fără să șteargă codul sau storage-ul.

Opcode-ul este marcat ca depreciat, iar compilatorul Solidity emite avertismente.

Ce rămâne important: ETH-ul poate ajunge într-un contract fără să treacă prin receive sau fallback:

  • un alt contract face selfdestruct cu tine ca beneficiar;
  • adresa ta primește recompense sau retrageri de validator;
  • ETH trimis la adresa unui contract înainte de deploy-ul lui (adresă precalculată).

Consecință:

SOLIDITY
// vulnerabil: oricine poate strica egalitatea forțând 1 wei în contract
require(address(this).balance == totalDeposits, "invariant");

Soluția este o contabilitate internă (totalDeposits), iar verificările să fie de tipul >= acolo unde surplusul este inofensiv.

La auditul contractelor mai vechi, selfdestruct și contractele metamorfice trebuie analizate cu regulile rețelei respective: nu toate lanțurile compatibile EVM au implementat EIP-6780 în același timp.

Ce urmărește intervievatorul: Se verifică dacă ești la curent cu schimbările de protocol și înțelegi primirea forțată de ETH. Greșeala tipică: a trata soldul contractului ca sursă de adevăr pentru contabilitate.

73 Senior

Ce riscuri apar la apelurile de nivel jos (call, delegatecall) cu valori returnate neverificate sau către adrese fără cod?

Răspuns scurt: call nu dă revert automat: dacă nu verifici success, eșecul trece neobservat. În plus, un call sau delegatecall către o adresă fără cod întoarce succes, iar datele returnate de un contract ostil pot consuma tot gas-ul la copiere.

Trei categorii de probleme:

1. Rezultat ignorat

SOLIDITY
payable(user).call{value: amount}("");   // dacă eșuează, contractul crede că a plătit

Contabilitatea marchează plata ca efectuată, deși banii au rămas în contract. Analizoarele statice (Slither: unchecked-lowlevel) semnalează asta.

2. Adresă fără cod

EVM tratează un apel către o adresă fără cod ca reușit, fără date returnate. Dacă un token a fost introdus greșit (adresa unui EOA sau un contract care nu există pe acel lanț), un apel de nivel jos la transfer „reușește”. SafeERC20 din OpenZeppelin verifică explicit existența codului atunci când apelul nu întoarce date. Același risc există la proxy-uri care fac delegatecall către o implementare inexistentă sau distrusă.

3. Return bomb și gas

SOLIDITY
(bool ok, bytes memory data) = untrusted.call(payload);

Solidity copiază automat toate datele returnate în memorie. Un contract ostil poate întoarce o cantitate uriașă de date, iar costul de expansiune a memoriei consumă gas-ul rămas, deci și funcția ta dă revert. Soluții: limitezi gas-ul transmis, folosești assembly pentru a copia doar primii octeți, sau biblioteci dedicate (de exemplu ExcessivelySafeCall).

Alte detalii:

  • regula celor 63/64 (EIP-150): un apel transmite cel mult 63/64 din gas-ul rămas, deci un apelant poate alege gas-ul astfel încât subapelul să eșueze, iar funcția ta să continue. Dacă subapelul este critic, verifică explicit rezultatul și gas-ul;
  • folosește interfețe tipizate acolo unde poți și lasă apelurile de nivel jos pentru cazurile în care chiar ai nevoie de ele.

Ce urmărește intervievatorul: La senior se așteaptă cunoașterea comportamentelor EVM care nu sunt evidente din Solidity. Greșeala tipică: a nu ști că un apel către o adresă fără cod raportează succes.

74 Senior

Cum proiectezi controlul administrativ al unui protocol ca să reduci riscul de chei compromise sau de abuz?

Răspuns scurt: Separi rolurile cu privilegii minime, pui cheile administrative într-un multisig, treci schimbările sensibile printr-un timelock, limitezi on-chain ce poate face adminul (plafoane, parametri în intervale) și păstrezi un rol de pauză de urgență cu putere restrânsă, totul documentat și monitorizat.

Multe pierderi mari din ecosistem nu au venit din bug-uri de cod, ci din chei administrative compromise. Designul trebuie să presupună că o cheie poate fi furată.

Principii:

  • Privilegii minime: roluri separate pentru upgrade, parametri, pauză, trezorerie. Rolul de pauză poate doar opri, nu poate muta fonduri.
  • Multisig (de exemplu Safe) cu un prag precum 3 din 5, semnatari independenți, hardware wallets și proceduri clare de verificare a ce se semnează.
  • Timelock (de exemplu TimelockController din OpenZeppelin): o schimbare se programează, este publică un interval de timp, apoi se execută. Utilizatorii și monitorizarea au timp să reacționeze.
  • Limite on-chain: adminul nu poate seta comisionul peste un maxim, nu poate schimba oracolul fără timelock, nu poate retrage depozitele utilizatorilor.
  • Monitorizare: alerte pentru orice event administrativ, programare sau execuție din timelock.
  • Plan de urgență: cine poate pune pe pauză, cum se iau deciziile, cum se comunică.
SOLIDITY
uint256 public constant MAX_FEE_BPS = 500; // 5%
event FeeChanged(uint256 oldFee, uint256 newFee);

function setFee(uint256 newFee) external onlyRole(PARAM_ROLE) {
    if (newFee > MAX_FEE_BPS) revert FeeTooHigh();
    emit FeeChanged(fee, newFee);
    fee = newFee;
}

Discuția matură include și compromisul: un timelock lung protejează utilizatorii, dar întârzie remedierea unei vulnerabilități. De aceea pauza de urgență rămâne rapidă, iar remedierea propriu-zisă trece prin timelock. Pe termen lung, unele protocoale renunță treptat la privilegii, pe măsură ce codul se maturizează.

Ce urmărește intervievatorul: La senior se verifică gândirea operațională și de guvernanță, nu doar cea de cod. Greșeala tipică: un singur EOA cu drept de upgrade și fără timelock.

Testare, unelte și Git (Hardhat, Foundry)

75 Junior

Cum organizezi în Git un proiect de smart contracts și ce nu trebuie să ajungă niciodată în repository?

Răspuns scurt: Ții în Git codul contractelor, testele, scripturile de deploy, configurația și fișierul de lock al dependențelor, iar artefactele de build și cache-ul le ignori. Cheile private, seed phrase-urile, cheile de API și fișierele .env nu trebuie să ajungă niciodată în repository.

Structură tipică pentru un proiect Foundry sau Hardhat:

  • src/ sau contracts/: contractele;
  • test/: testele;
  • script/ sau scripts/: deploy și operațiuni;
  • foundry.toml / hardhat.config.ts, package.json cu fișierul de lock;
  • lib/ (Foundry, dependențe ca git submodules) sau node_modules/ (ignorat).

Un .gitignore minim:

.env
node_modules/
out/
cache/
artifacts/
typechain-types/
broadcast/*/31337/
coverage/

De ce contează atât de mult secretele: o cheie privată publicată într-un repository public este de obicei golită automat de bots în foarte scurt timp. Ștergerea ulterioară dintr-un commit nu ajută, pentru că rămâne în istoric și în copiile deja făcute. Dacă s-a întâmplat, consideri cheia compromisă: muți fondurile și rolurile pe o cheie nouă, apoi cureți istoricul.

Bune practici:

  • .env.example cu numele variabilelor, fără valori;
  • pentru deploy, chei ținute în keystore criptat (cast wallet import) sau hardware wallet, nu în text clar;
  • un scanner de secrete în pre-commit sau în CI (de exemplu gitleaks);
  • commit-uri mici, cu mesaje clare, și tag-uri pentru versiunile deployate, ca să poți lega o adresă de pe lanț de commit-ul exact;
  • adresele de deploy salvate în fișiere versionate pe rețea, nu doar în notițe.

Branching: lucrul pe ramuri cu pull request și review obligatoriu înainte de main este și mai important aici decât în alte proiecte, pentru că după deploy codul nu se mai poate corecta ușor.

Ce urmărește intervievatorul: Se verifică igiena de bază a proiectului și înțelegerea riscului secretelor. Greșeala tipică: o cheie privată de test, folosită și pe mainnet, comisă în repository.

76 Junior

Care sunt diferențele principale dintre Hardhat și Foundry?

Răspuns scurt: Hardhat este un mediu bazat pe Node.js, cu teste și scripturi de obicei în JavaScript sau TypeScript. Foundry este un set de unelte în Rust (forge, cast, anvil, chisel), cu teste scrise în Solidity, foarte rapid și cu fuzzing integrat.

Hardhat (versiunea 2, cu @nomicfoundation/hardhat-toolbox; Hardhat 3 a adus și suport pentru teste în Solidity):

  • teste cu Mocha și Chai, interacțiune prin ethers.js;
  • ecosistem mare de pluginuri: gas reporter, verificare pe Etherscan, OpenZeppelin Upgrades, TypeChain;
  • natural dacă echipa scrie deja mult TypeScript și vrea teste apropiate de modul în care front-end-ul folosește contractele;
  • Hardhat Network: rețea locală cu console.log în Solidity și stack traces lizibile.

Foundry:

  • forge pentru build și teste, cast pentru interacțiuni din linia de comandă, anvil pentru nod local, chisel ca REPL Solidity;
  • testele sunt contracte Solidity, cu „cheatcodes” prin vm (de exemplu vm.prank, vm.warp, vm.expectRevert);
  • fuzzing și invariant testing incluse, foarte rapide;
  • scripturi de deploy în Solidity (forge script).
BASH
forge init demo && cd demo
forge build
forge test -vvv
anvil                      # nod local
cast call $TOKEN "totalSupply()(uint256)" --rpc-url http://127.0.0.1:8545

În practică, multe echipe le combină: Foundry pentru testele contractelor și fuzzing, Hardhat sau scripturi TypeScript pentru integrare și tooling de front-end. La interviu e bine să ai experiență cu cel puțin unul și să știi argumentele pentru celălalt, fără să tratezi alegerea ca pe o chestiune de preferință personală.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat real cu uneltele și știi compromisurile. Greșeala tipică: a nu putea numi componentele Foundry sau a nu ști că testele Foundry sunt în Solidity.

77 Junior

Scrie un test Hardhat pentru un contract Counter care verifică incrementarea, event-ul și refuzul pentru un apelant neautorizat.

Răspuns scurt: Într-un test Hardhat folosești un fixture încărcat cu loadFixture, obții contractul prin ethers.deployContract, apoi verifici starea cu expect, event-urile cu .to.emit(...).withArgs(...) și erorile cu .to.be.revertedWithCustomError(...).

Presupunem contractul Counter cu increment(), reset() protejat de owner, event-ul Incremented(address by, uint256 newCount) și eroarea NotOwner(). Test pentru Hardhat 2 cu hardhat-toolbox și ethers v6:

TypeScript
import { expect } from "chai";
import { ethers } from "hardhat";
import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers";

describe("Counter", () => {
  async function deployFixture() {
    const [owner, other] = await ethers.getSigners();
    const counter = await ethers.deployContract("Counter");
    return { counter, owner, other };
  }

  it("incrementează și emite event", async () => {
    const { counter, other } = await loadFixture(deployFixture);
    await expect(counter.connect(other).increment())
      .to.emit(counter, "Incremented")
      .withArgs(other.address, 1n);
    expect(await counter.count()).to.equal(1n);
  });

  it("refuză reset de la non-owner", async () => {
    const { counter, other } = await loadFixture(deployFixture);
    await expect(counter.connect(other).reset())
      .to.be.revertedWithCustomError(counter, "NotOwner");
  });
});

Ce merită explicat:

  • loadFixture face snapshot la starea rețelei locale după primul deploy și revine la ea pentru fiecare test, deci testele sunt izolate și rapide;
  • în ethers v6 numerele mari sunt bigint, de aceea compari cu 1n;
  • connect(other) trimite tranzacția de pe alt cont, util pentru testarea permisiunilor;
  • pentru fiecare funcție protejată scrii cel puțin un test pozitiv și unul negativ.

Rulare: npx hardhat test, iar cu REPORT_GAS=true obții și raportul de gas dacă este configurat pluginul.

Ce urmărește intervievatorul: Este o întrebare practică: se verifică dacă ai scris teste reale și cunoști API-ul actual. Greșeala tipică: sintaxa ethers v5 (BigNumber, deployed()) amestecată cu v6.

78 Junior

Cum testezi în Foundry că o funcție dă revert cu o anumită eroare și că emite un event?

Răspuns scurt: Folosești cheatcode-urile vm.expectRevert (cu selectorul sau codificarea erorii) și vm.expectEmit, apelate imediat înainte de apelul testat. Cu vm.prank simulezi apelantul, iar cu vm.deal dai ETH unei adrese.

Test pentru vault-ul de ETH cu erorile InsufficientBalance(uint256,uint256) și event-ul Withdrawn(address indexed user, uint256 amount):

SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {Test} from "forge-std/Test.sol";
import {EthVault} from "../src/EthVault.sol";

contract EthVaultTest is Test {
    EthVault vault;
    address alice = makeAddr("alice");

    event Withdrawn(address indexed user, uint256 amount);

    function setUp() public {
        vault = new EthVault();
        vm.deal(alice, 10 ether);
        vm.prank(alice);
        vault.deposit{value: 1 ether}();
    }

    function test_RevertWhen_WithdrawTooMuch() public {
        vm.prank(alice);
        vm.expectRevert(abi.encodeWithSelector(EthVault.InsufficientBalance.selector, 1 ether, 2 ether));
        vault.withdraw(2 ether);
    }

    function test_EmitsWithdrawn() public {
        vm.expectEmit(true, false, false, true, address(vault));
        emit Withdrawn(alice, 0.5 ether);
        vm.prank(alice);
        vault.withdraw(0.5 ether);
        assertEq(alice.balance, 9.5 ether);
    }
}

Explicații:

  • vm.prank(addr) setează msg.sender doar pentru următorul apel; vm.startPrank pentru mai multe;
  • vm.expectRevert se aplică următorului apel; ordinea față de prank nu contează, dar trebuie să fie înaintea apelului testat;
  • în vm.expectEmit, primele trei valori spun ce topics indexate să compare, a patra dacă se compară data, iar ultimul argument este emitentul așteptat;
  • emiți apoi event-ul așteptat, iar Foundry îl compară cu ce emite apelul următor.

Rulezi cu forge test -vvvv ca să vezi trace-ul complet la eșec.

Ce urmărește intervievatorul: Se verifică familiaritatea cu cheatcode-urile de bază. Greșeala tipică: vm.prank urmat de două apeluri, presupunând că ambele vin de la aceeași adresă.

79 Junior

Ce diferență este între rețeaua locală (Hardhat Network, Anvil), un testnet (de exemplu Sepolia) și mainnet? Când folosești fiecare?

Răspuns scurt: Rețeaua locală rulează pe calculatorul tău, instantanee, gratuită și resetabilă, pentru dezvoltare și teste. Testnet-ul este o rețea publică cu ETH fără valoare, pentru integrare reală. Mainnet-ul este producția, unde fiecare tranzacție costă bani reali și este permanentă.

Rețea locală:

  • Hardhat Network (pornit automat de npx hardhat test sau cu npx hardhat node) ori Anvil (anvil);
  • conturi preîncărcate cu ETH de test, blocuri minate imediat, posibilitatea de a manipula timpul și soldurile;
  • folosită pentru ciclul zilnic: scrii cod, rulezi teste, repeți;
  • poate rula și ca fork al unei rețele reale, ca să testezi cu contracte deja existente.

Testnet (Sepolia pentru aplicații; Holesky și succesorul său Hoodi sunt orientate mai mult spre validatori și infrastructură):

  • consens real, timp real de bloc, explorer de blocuri, RPC-uri publice;
  • ETH obținut gratuit de la faucets;
  • folosit pentru: verificarea deploy-ului, testarea front-end-ului cu MetaMask, integrarea cu oracole sau servicii care au deploy pe testnet, demo-uri pentru echipă.

Mainnet:

  • deploy doar după teste, review și, pentru contracte care țin valoare, audit;
  • scripturi de deploy repetabile, deja încercate pe testnet;
  • verificarea codului sursă pe explorer imediat după deploy.
BASH
forge script script/Deploy.s.sol --rpc-url $SEPOLIA_RPC_URL --account deployer --broadcast --verify

Atenție la diferențe: unele contracte externe (tokenuri, oracole) au alte adrese pe testnet sau nu există deloc. Păstrează adresele într-o configurație per rețea, iar conturile de test nu le refolosi niciodată pe mainnet. Și rețelele Layer 2 au propriile testnet-uri, de obicei legate de Sepolia.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai un flux de lucru matur de la local la producție. Greșeala tipică: a testa direct pe testnet ce se putea verifica local în câteva secunde.

80 Mid

Ce este fuzz testing în Foundry și ce fel de bug-uri găsește?

Răspuns scurt: Scrii un test cu parametri, iar Foundry îl rulează de multe ori cu valori generate automat, căutând un input care încalcă aserțiunile. Găsește bug-uri la limite: overflow, rotunjiri, valori zero sau maxime, combinații pe care nu le-ai scrie manual.

Orice funcție de test cu parametri devine un fuzz test:

SOLIDITY
function testFuzz_DepositWithdraw(uint96 amount) public {
    vm.assume(amount > 0);
    vm.deal(alice, amount);

    vm.startPrank(alice);
    vault.deposit{value: amount}();
    vault.withdraw(amount);
    vm.stopPrank();

    assertEq(alice.balance, amount);
    assertEq(vault.balanceOf(alice), 0);
}

Concepte:

  • numărul de rulări: implicit 256, configurabil cu --fuzz-runs sau în foundry.toml ([fuzz] runs = 10000);
  • vm.assume elimină input-urile care nu au sens, dar dacă respingi prea multe, testul eșuează. Pentru intervale este mai bun bound(x, min, max), care transformă valoarea în loc să o arunce;
  • shrinking: când găsește un contraexemplu, Foundry încearcă să-l reducă la cea mai simplă valoare care reproduce eroarea;
  • Foundry folosește dicționare cu valori de interes (constante din cod, valori limită), deci găsește rapid cazurile la margine.

Bug-uri tipice găsite:

  • rotunjiri care permit retragerea a 1 wei în plus sau blochează ultima retragere;
  • calcule de procent care dau revert pentru sume mari;
  • condiții < vs <= greșite;
  • conversii cu trunchiere.

Proprietăți bune de testat: operații inverse (depui și retragi aceeași sumă), conservarea totalului, monotonia (mai mult depus nu dă mai puține share-uri), comparația cu o implementare de referință simplă. Fuzzing-ul nu înlocuiește testele unitare clare, dar acoperă un spațiu de input pe care nu l-ai acoperi niciodată manual.

Ce urmărește intervievatorul: Se verifică dacă știi să formulezi proprietăți, nu doar să adaugi parametri. Greșeala tipică: vm.assume prea restrictiv, care face fuzzer-ul să respingă majoritatea input-urilor.

81 Mid

Ce înseamnă să rulezi testele pe un fork de mainnet și când este util?

Răspuns scurt: Un fork este o rețea locală care copiază la cerere starea reală a unei rețele la un anumit bloc, deci interacționezi cu contracte deja deployate fără costuri și fără risc. E util la teste de integrare, reproducerea incidentelor și verificarea upgrade-urilor.

Rețeaua locală cere starea de la un nod RPC doar când are nevoie de ea, o păstrează în cache, iar modificările tale rămân locale.

BASH
# Foundry
forge test --fork-url $MAINNET_RPC_URL --fork-block-number 21000000 -vvv
anvil --fork-url $MAINNET_RPC_URL

# Hardhat (hardhat.config): networks.hardhat.forking = { url, blockNumber }

În teste Foundry poți crea fork-uri din cod:

SOLIDITY
function setUp() public {
    vm.createSelectFork(vm.envString("MAINNET_RPC_URL"), 21_000_000);
}

function test_SwapOnRealPool() public {
    deal(address(usdc), alice, 1_000e6); // setează soldul de token
    vm.startPrank(alice);
    usdc.approve(address(router), 1_000e6);
    // apel real către router
    vm.stopPrank();
}

Când e util:

  • integrarea cu protocoale existente, unde mock-urile ar ascunde comportamente reale (tokenuri ciudate, rotunjiri, taxe);
  • verificarea unui upgrade: faci upgrade-ul pe fork și rulezi teste pe starea reală a utilizatorilor;
  • analiza unui incident: reproduci tranzacția atacatorului la blocul dinaintea atacului;
  • simularea unei propuneri de guvernanță înainte de vot.

Bune practici:

  • fixează mereu blockNumber, altfel testele devin nedeterministe și lente;
  • folosește un RPC care suportă date istorice la acel bloc (de obicei archive);
  • ține URL-ul RPC în variabile de mediu;
  • separă testele pe fork de testele unitare, ca suita principală să rămână rapidă și independentă de rețea.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu integrarea reală și depanarea. Greșeala tipică: fork fără bloc fixat, cu teste care trec azi și pică mâine.

82 Mid

Cum faci deploy unui contract pe o rețea publică și cum îi verifici codul sursă pe explorer?

Răspuns scurt: Scrii un script de deploy repetabil (forge script sau Hardhat Ignition), îl rulezi întâi pe testnet cu o cheie păstrată în siguranță, salvezi adresele și verifici codul pe explorer cu aceleași setări de compilator, de obicei automat cu --verify.

Exemplu de script Foundry:

SOLIDITY
// script/Deploy.s.sol
pragma solidity 0.8.24;
import {Script, console} from "forge-std/Script.sol";
import {AcademyToken} from "../src/AcademyToken.sol";

contract Deploy is Script {
    function run() external {
        address owner = vm.envAddress("OWNER");
        vm.startBroadcast();
        AcademyToken t = new AcademyToken(owner);
        vm.stopBroadcast();
        console.log("AcademyToken:", address(t));
    }
}
BASH
cast wallet import deployer --interactive   # cheia se salvează criptat
forge script script/Deploy.s.sol --rpc-url $SEPOLIA_RPC_URL --account deployer --broadcast --verify

Fără --broadcast, scriptul doar simulează. Foundry salvează tranzacțiile în broadcast/, util pentru a ști exact ce s-a deployat.

Verificarea înseamnă că explorer-ul recompilează sursa ta și compară bytecode-ul cu cel de pe lanț. Trebuie să coincidă: versiunea compilatorului, optimizer-ul și runs, versiunea EVM, argumentele constructorului, bibliotecile linkate. Dacă ai fixat versiunea și setările în configurație, verificarea automată funcționează de obicei din prima.

Listă de control înainte de mainnet:

  • același script, rulat cu succes pe testnet și pe un fork;
  • proprietarul și rolurile setate pe multisig, nu pe cheia de deploy;
  • inițializarea făcută în aceeași tranzacție cu deploy-ul, pentru proxy-uri;
  • adresele și commit-ul salvate și etichetate în Git;
  • cheia de deploy eliberată de orice privilegiu după deploy.

Ce urmărește intervievatorul: Se verifică dacă ai făcut deploy-uri reale și te gândești la siguranța cheilor. Greșeala tipică: cheie privată în .env în text clar și roluri lăsate pe contul de deploy.

83 Mid

Ce este invariant testing și cum l-ai folosi pentru un vault sau un token?

Răspuns scurt: Invariant testing verifică proprietăți care trebuie să rămână adevărate după orice secvență de apeluri, generată aleator de fuzzer, de exemplu „totalul depus este egal cu soldul contractului”. În Foundry, definești funcții invariant_* și un contract handler care limitează apelurile la acțiuni realiste.

Spre deosebire de fuzzing-ul unei singure funcții, aici fuzzer-ul apelează funcții în ordine aleatoare, cu actori și valori aleatoare, iar după fiecare secvență verifică invarianții.

Un handler este un contract intermediar care expune acțiuni valide și ține evidențe auxiliare (ghost variables):

SOLIDITY
contract Handler is Test {
    EthVault vault;
    uint256 public ghostDeposited;
    uint256 public ghostWithdrawn;

    constructor(EthVault v) { vault = v; }

    function deposit(uint256 amt) external {
        amt = bound(amt, 1, 100 ether);
        vm.deal(msg.sender, amt);
        vm.prank(msg.sender);
        vault.deposit{value: amt}();
        ghostDeposited += amt;
    }

    function withdraw(uint256 amt) external {
        uint256 bal = vault.balanceOf(msg.sender);
        if (bal == 0) return;
        amt = bound(amt, 1, bal);
        vm.prank(msg.sender);
        vault.withdraw(amt);
        ghostWithdrawn += amt;
    }
}

contract VaultInvariants is Test {
    EthVault vault; Handler h;
    function setUp() public {
        vault = new EthVault(); h = new Handler(vault);
        targetContract(address(h));
    }
    function invariant_Solvency() public view {
        assertEq(address(vault).balance, h.ghostDeposited() - h.ghostWithdrawn());
    }
}

Invarianți tipici:

  • solvabilitate: activele contractului acoperă toate datoriile față de utilizatori;
  • suma soldurilor unui token este egală cu totalSupply;
  • un utilizator nu poate retrage mai mult decât a depus plus câștigurile cuvenite.

Dificultatea reală este să formulezi invarianții corect și să construiești handler-e care explorează stări interesante. Când un invariant pică, Foundry arată secvența de apeluri care l-a încălcat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să gândești în proprietăți de sistem. Greșeala tipică: invariant testing direct pe contract, fără handler, cu majoritatea apelurilor dând revert.

84 Senior

Cum ai configura un pipeline de CI pentru un repository de smart contracts?

Răspuns scurt: La fiecare pull request rulezi automat: compilarea cu setările de producție, formatarea, testele unitare și fuzz, testele pe fork (eventual separat), analiza statică (Slither), un snapshot de gas comparat cu main și verificarea dimensiunii contractelor. Merge-ul este blocat dacă un pas pică.

Exemplu de workflow GitHub Actions pentru Foundry:

YAML
name: contracts
on: [pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - uses: foundry-rs/foundry-toolchain@v1
      - run: forge fmt --check
      - run: forge build --sizes
      - run: forge test -vvv
        env:
          FOUNDRY_FUZZ_RUNS: "5000"
      - run: forge snapshot --check
  slither:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - uses: crytic/slither-action@v0.4.0

Ce aduce fiecare pas:

  • forge build --sizes arată dimensiunea contractelor; un contract peste 24 KB (EIP-170) nu poate fi deployat pe Ethereum mainnet;
  • forge snapshot --check compară gas-ul cu un fișier .gas-snapshot versionat, deci o regresie de gas devine vizibilă în review;
  • Slither rulează pe tot codul; avertismentele acceptate se documentează explicit, ca să nu se piardă cele noi printre ele;
  • testele pe fork au nevoie de un URL RPC, păstrat ca secret de CI, și de bloc fixat; de obicei rulează într-un job separat sau programat.

Pe partea de Git: protecția ramurii main, review obligatoriu de la cel puțin doi colegi pentru contractele care țin valoare, tag-uri semantice pentru fiecare versiune deployată și un fișier de adrese per rețea legat de tag. Deploy-ul pe mainnet rămâne de obicei manual, din multisig, dar pipeline-ul pregătește și simulează tranzacțiile, ca semnatarii să verifice exact ce aprobă.

Ce urmărește intervievatorul: La senior se verifică automatizarea calității și disciplina de release. Greșeala tipică: CI care rulează doar testele, fără analiză statică, gas și dimensiune.

JavaScript, ethers.js, Python și dApps

85 Junior

Ce este ethers.js și care este diferența dintre un Provider și un Signer în ethers v6?

Răspuns scurt: ethers.js este o bibliotecă JavaScript pentru interacțiunea cu rețele compatibile EVM. Un Provider oferă acces read-only la blockchain (blocuri, solduri, apeluri view), iar un Signer reprezintă un cont care poate semna mesaje și trimite tranzacții.

În ethers v6:

JavaScript
import { ethers } from "ethers";

// Provider: citire
const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
const block = await provider.getBlockNumber();
const balance = await provider.getBalance("0x...");

// Signer în browser, prin wallet-ul utilizatorului (EIP-1193)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();

// Signer în backend, cu o cheie (doar pentru servicii proprii, cu cheia în secret manager)
const wallet = new ethers.Wallet(process.env.BOT_KEY, provider);

Contractele se instanțiază cu un ABI și cu un runner:

  • new ethers.Contract(address, abi, provider) permite doar citiri;
  • new ethers.Contract(address, abi, signer) permite și tranzacții.

Schimbări importante față de v5, întrebate des:

  • numerele mari sunt bigint nativ (10n), nu BigNumber;
  • utilitarele sunt direct pe ethers: ethers.parseEther, ethers.formatUnits, nu ethers.utils.*;
  • Web3Provider a devenit BrowserProvider, iar getSigner() este asincron;
  • contract.target este adresa contractului, iar waitForDeployment() înlocuiește deployed().

Separarea Provider/Signer reflectă un principiu de securitate: codul care doar afișează date nu are nevoie de acces la chei. În aplicațiile web, cheile rămân în wallet-ul utilizatorului, iar aplicația doar cere semnături. Alternative populare la ethers sunt viem (cu wagmi pentru React) și web3.js, cu concepte similare.

Ce urmărește intervievatorul: Se verifică dacă știi modelul de bază și versiunea curentă a bibliotecii. Greșeala tipică: amestecarea sintaxei v5 și v6 în același cod.

86 Junior

Cum conectezi o aplicație web la wallet-ul utilizatorului, de exemplu MetaMask?

Răspuns scurt: Wallet-ul injectează un provider EIP-1193 (window.ethereum), iar aplicația cere acces la conturi cu eth_requestAccounts, verifică rețeaua prin chainId, apoi folosește un Signer pentru tranzacții. Trebuie tratate refuzul utilizatorului, schimbarea contului și schimbarea rețelei.

Flux minim cu ethers v6:

JavaScript
import { ethers } from "ethers";

async function connect() {
  if (!window.ethereum) throw new Error("Nu există wallet instalat");
  const provider = new ethers.BrowserProvider(window.ethereum);
  await provider.send("eth_requestAccounts", []);      // deschide fereastra wallet-ului
  const signer = await provider.getSigner();
  const { chainId } = await provider.getNetwork();
  if (chainId !== 11155111n) {                          // Sepolia
    await window.ethereum.request({
      method: "wallet_switchEthereumChain",
      params: [{ chainId: "0xaa36a7" }],
    });
  }
  return signer;
}

window.ethereum?.on("accountsChanged", () => location.reload());
window.ethereum?.on("chainChanged", () => location.reload());

Aspecte de reținut:

  • conectarea nu dă aplicației acces la cheie; fiecare tranzacție sau semnătură este aprobată separat de utilizator;
  • utilizatorul poate refuza: eroarea are codul 4001 (EIP-1193), pe care îl tratezi cu un mesaj prietenos, nu cu o eroare generică;
  • când există mai multe wallet-uri instalate, ele concurează pentru window.ethereum. EIP-6963 rezolvă asta: wallet-urile se anunță prin events, iar aplicația afișează lista;
  • pentru mobil și pentru wallet-uri externe se folosește WalletConnect;
  • în producție, multe echipe folosesc biblioteci precum wagmi cu RainbowKit sau Web3Modal, care tratează aceste cazuri;
  • „Sign-In with Ethereum” (EIP-4361) este standardul pentru autentificare pe baza unei semnături, dacă ai nevoie de sesiune pe backend.

Nu afișa niciodată cereri de semnătură fără explicații: utilizatorul trebuie să înțeleagă ce aprobă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai construit efectiv un front-end dApp și ai tratat cazurile neplăcute. Greșeala tipică: ignorarea schimbării de rețea și a refuzului utilizatorului.

87 Junior

Ce este ABI-ul unui contract și la ce folosește?

Răspuns scurt: ABI (Application Binary Interface) este descrierea, de obicei în JSON, a funcțiilor, events și erorilor unui contract, cu tipurile parametrilor. Bibliotecile o folosesc ca să codifice apelurile în calldata și să decodifice rezultatele, events și erorile.

Pe lanț, un contract este doar bytecode. Ca să apelezi transfer(address,uint256), trebuie să trimiți în calldata:

  • selectorul: primii 4 octeți din keccak256("transfer(address,uint256)"), adică 0xa9059cbb;
  • argumentele codificate după regulile ABI: fiecare valoare statică pe 32 de octeți, iar tipurile dinamice prin offset și lungime.

ABI-ul spune bibliotecii ce tipuri are fiecare funcție, ca să facă această codificare automat. Este generat de compilator (out/ în Foundry, artifacts/ în Hardhat).

JavaScript
// ethers v6: ABI în format „human-readable”
const abi = [
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "event Transfer(address indexed from, address indexed to, uint256 value)",
  "error InsufficientBalance(uint256 available, uint256 required)",
];
const token = new ethers.Contract(tokenAddress, abi, signer);

const iface = new ethers.Interface(abi);
const data = iface.encodeFunctionData("transfer", [to, 1000n]); // calldata brut

Utilizări:

  • apeluri și tranzacții din front-end sau backend;
  • decodarea events din receipts și a erorilor custom;
  • generarea de tipuri TypeScript (TypeChain, viem);
  • unelte precum cast (cast calldata, cast 4byte-decode).

Detalii practice: ai nevoie doar de fragmentele pe care le folosești. Pentru contractele verificate, ABI-ul se poate lua de pe explorer. Pentru proxy-uri, folosești ABI-ul implementării cu adresa proxy-ului. Două funcții diferite pot avea, rar, același selector; compilatorul refuză asta în același contract, dar nu și între proxy și implementare.

Ce urmărește intervievatorul: Se verifică dacă înțelegi ce se întâmplă sub API-ul comod al bibliotecilor. Greșeala tipică: a folosi ABI-ul proxy-ului în loc de cel al implementării.

88 Junior

Ce afișează codul următor în ethers v6 și de ce? (wei, zecimale și bigint)

Răspuns scurt: Afișează 1000000000000000000n, apoi 1.5, apoi 1500000 și eroare la ultima linie. Valorile on-chain sunt întregi în cea mai mică unitate, iar ethers v6 le reprezintă ca bigint, care nu se poate amesteca cu number în operații aritmetice.

Codul:

JavaScript
import { ethers } from "ethers";

console.log(ethers.parseEther("1"));                  // 1000000000000000000n
console.log(ethers.formatEther(1500000000000000000n)); // "1.5"
console.log(ethers.parseUnits("1.5", 6).toString());   // "1500000" (USDC are 6 zecimale)
console.log(ethers.parseEther("1") + 1);              // TypeError

Explicații:

  • ETH are 18 zecimale: 1 ETH = 10 la puterea 18 wei. parseEther("1") întoarce valoarea în wei ca bigint, iar console.log afișează bigint-urile cu sufixul n;
  • formatEther face operația inversă și întoarce un string, pentru afișare;
  • tokenurile pot avea alt număr de zecimale. Pentru USDC (6 zecimale), parseUnits("1.5", 6) dă 1.500.000. Citește întotdeauna decimals() de la contract, nu presupune 18;
  • în JavaScript, bigint + number aruncă TypeError: Cannot mix BigInt and other types. Scrii + 1n.

De ce nu folosim number: Number.MAX_SAFE_INTEGER este aproximativ 9 * 10 la puterea 15, mult sub valorile uzuale în wei. Calculele cu number pierd precizie fără eroare, ceea ce în aplicații financiare este grav. Același motiv explică de ce nu faci parseFloat pe sume.

Regulă de lucru: în cod ții totul în unități întregi (bigint), convertești la string formatat doar la afișare, iar input-ul utilizatorului îl transformi cu parseUnits folosind zecimalele tokenului.

Ce urmărește intervievatorul: Este o întrebare de tip „ce afișează” care prinde rapid lipsa de experiență practică. Greșeala tipică: calcule cu number și presupunerea că toate tokenurile au 18 zecimale.

89 Junior

Cum asculți events ale unui contract din aplicație și cum citești istoricul lor?

Răspuns scurt: Pentru istoric folosești contract.queryFilter(filter, fromBlock, toBlock), care face eth_getLogs pe un interval de blocuri. Pentru timp real folosești contract.on(event, handler) sau abonare prin WebSocket. Ambele se bazează pe topics, deci poți filtra după parametrii indexed.

Exemple în ethers v6:

JavaScript
const token = new ethers.Contract(address, abi, provider);

// istoric: transferurile primite de `me` în ultimele 10.000 de blocuri
const filter = token.filters.Transfer(null, me);
const latest = await provider.getBlockNumber();
const logs = await token.queryFilter(filter, latest - 10_000, latest);
for (const log of logs) {
  const { from, to, value } = log.args;
  console.log(log.blockNumber, from, to, ethers.formatUnits(value, 18));
}

// timp real
token.on(filter, (from, to, value, event) => {
  console.log("Transfer nou", value, event.log.transactionHash);
});

Aspecte practice:

  • furnizorii RPC limitează intervalul de blocuri sau numărul de rezultate pentru eth_getLogs. Pentru istoric lung, iterezi în bucăți și salvezi progresul;
  • contract.on cu un JsonRpcProvider HTTP folosește polling; pentru latență mică și cost redus folosești WebSocketProvider, cu reconectare la căderea conexiunii;
  • events vin din blocuri ne-finalizate și pot fi eliminate la un reorg. În ethers, log-urile au câmpul removed; pentru logică importantă, aștepți confirmări;
  • dacă aplicația are nevoie de date agregate (de exemplu „top deținători”), interogarea directă a log-urilor din browser nu scalează și ai nevoie de un indexer.

Un truc util: cu provider.getLogs({ address, topics }) poți filtra la nivel de topic chiar fără ABI complet, iar cu iface.parseLog(log) decodezi rezultatul. Așa scrii unelte generice de monitorizare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să construiești funcționalități bazate pe events și le cunoști limitele. Greșeala tipică: queryFilter de la blocul 0 pe un RPC public.

90 Mid

Cum gestionezi în front-end ciclul de viață al unei tranzacții: trimitere, așteptare, erori?

Răspuns scurt: Simulezi întâi tranzacția (estimare de gas sau staticCall) ca să prinzi revert-urile devreme, trimiți și afișezi hash-ul, aștepți receipt-ul cu tx.wait(), verifici status și tratezi separat erorile: refuz al utilizatorului, revert cu eroare custom, fonduri insuficiente, tranzacție înlocuită sau blocată.

Un flux robust cu ethers v6:

JavaScript
async function deposit(vault, amount) {
  try {
    await vault.deposit.staticCall({ value: amount });     // simulare: revert-urile apar aici
    const tx = await vault.deposit({ value: amount });     // utilizatorul semnează
    showPending(tx.hash);
    const receipt = await tx.wait(1);                      // așteaptă includerea
    if (receipt.status !== 1) throw new Error("Tranzacția a eșuat");
    showSuccess(receipt.hash);
  } catch (err) {
    if (ethers.isError(err, "ACTION_REJECTED")) return showInfo("Ai anulat tranzacția.");
    if (ethers.isError(err, "INSUFFICIENT_FUNDS")) return showError("Fonduri insuficiente pentru gas.");
    if (ethers.isError(err, "CALL_EXCEPTION")) {
      const parsed = err.data ? vault.interface.parseError(err.data) : null;
      return showError(parsed ? `Refuzat: ${parsed.name}` : "Contractul a refuzat operația.");
    }
    if (ethers.isError(err, "TRANSACTION_REPLACED") && !err.cancelled) {
      return showSuccess(err.receipt.hash);                // accelerată de utilizator
    }
    showError("Eroare neașteptată");
  }
}

Puncte de discutat:

  • starea UI are mai multe faze: aștept semnătura, trimisă, confirmată, eșuată. Butonul trebuie dezactivat ca să nu se trimită de două ori;
  • erorile custom se decodează cu ABI-ul contractului și se traduc în mesaje înțelese de utilizator;
  • înlocuirea: utilizatorul poate accelera tranzacția din wallet, deci hash-ul se schimbă; ethers semnalează asta;
  • persistența: dacă utilizatorul închide pagina, salvezi hash-ul și reiei urmărirea la revenire;
  • după succes, reîncarci datele afectate (solduri, liste), eventual cu o mică întârziere, pentru furnizori RPC care nu sunt încă sincronizați.

Ce urmărește intervievatorul: Se verifică dacă ai construit experiențe reale pentru utilizatori, nu doar apeluri care merg pe drumul fericit. Greșeala tipică: un singur mesaj generic pentru toate erorile.

91 Mid

Cum citești date și events dintr-un contract folosind Python (web3.py)?

Răspuns scurt: Creezi o instanță Web3 cu un provider HTTP sau WebSocket, construiești contractul din adresă și ABI, citești cu contract.functions.f().call() și obții events cu contract.events.Nume.get_logs(...), iterând pe intervale de blocuri. Este o alegere bună pentru scripturi de analiză, monitorizare și backend.

Exemplu pentru web3.py v7 (în v6 parametrul se numea fromBlock):

PYTHON
import os
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(os.environ["RPC_URL"]))
assert w3.is_connected()

ABI = [
    {"name": "decimals", "type": "function", "stateMutability": "view",
     "inputs": [], "outputs": [{"type": "uint8"}]},
    {"name": "Transfer", "type": "event", "anonymous": False, "inputs": [
        {"name": "from", "type": "address", "indexed": True},
        {"name": "to", "type": "address", "indexed": True},
        {"name": "value", "type": "uint256", "indexed": False}]},
]

token = w3.eth.contract(address=Web3.to_checksum_address(os.environ["TOKEN"]), abi=ABI)
decimals = token.functions.decimals().call()

latest = w3.eth.block_number
step = 2_000
for start in range(latest - 20_000, latest + 1, step):
    end = min(start + step - 1, latest)
    for ev in token.events.Transfer.get_logs(from_block=start, to_block=end):
        value = ev["args"]["value"] / 10 ** decimals
        print(ev["blockNumber"], ev["args"]["from"], ev["args"]["to"], value)

Observații:

  • adresele trebuie trecute în format checksum; to_checksum_address evită erorile;
  • iterarea pe bucăți de blocuri respectă limitele furnizorilor RPC;
  • împărțirea la 10 ** decimals produce float, potrivit doar pentru afișare. Pentru calcule păstrezi întregii sau folosești decimal.Decimal;
  • pentru tranzacții, construiești cu build_transaction, semnezi cu w3.eth.account.sign_transaction folosind o cheie din secret manager și trimiți tranzacția brută;
  • pe lanțuri cu particularități (de exemplu unele rețele PoA), pot fi necesare middleware-uri specifice.

Python este des folosit în echipe blockchain pentru analize on-chain, boți de monitorizare, scripturi de operațiuni și testare (de exemplu cu Ape sau Brownie, acesta din urmă nemaifiind întreținut).

Ce urmărește intervievatorul: Intervievatorul verifică dacă te descurci și în afara ecosistemului JavaScript. Greșeala tipică: calcule financiare cu float și interogări pe intervale prea mari.

92 Mid

De ce ai nevoie de un indexer (de exemplu The Graph sau un serviciu propriu) în loc să interoghezi direct blockchain-ul?

Răspuns scurt: Nodurile sunt optimizate pentru starea curentă și pentru căutări după cheie, nu pentru interogări de tip „toate ordinele utilizatorului X sortate după dată”. Un indexer procesează events o singură dată și le scrie într-o bază de date interogabilă, rapidă și cu paginare.

Limitări ale interogării directe prin RPC:

  • nu poți face filtre complexe, join-uri, agregări sau sortări;
  • eth_getLogs pe intervale mari este lent și limitat de furnizori;
  • mapările nu sunt enumerabile, deci nu poți lista „toți utilizatorii” din storage;
  • fiecare vizitator al site-ului ar repeta aceleași interogări costisitoare.

Un indexer:

  • ascultă events (și eventual apeluri sau blocuri), le transformă în entități și le scrie într-o bază de date;
  • expune un API (GraphQL în The Graph, REST sau GraphQL într-un serviciu propriu);
  • tratează reorg-urile și reluarea de la un anumit bloc.

Variante:

  • The Graph: definești o schemă GraphQL și „mappings” în AssemblyScript pentru fiecare event; subgraph-ul poate fi găzduit de rețeaua descentralizată The Graph;
  • alte unelte precum Ponder sau Envio, ori soluții proprii: un worker în Node.js sau Python care citește log-urile pe bucăți și scrie în PostgreSQL.
GRAPHQL
type Deposit @entity(immutable: true) {
  id: Bytes!
  user: Bytes!
  amount: BigInt!
  blockNumber: BigInt!
}

Implicație de design pentru contracte: indexer-ul vede doar ce emiți. Dacă o schimbare importantă nu are event, va trebui reconstruită prin citiri de storage la fiecare bloc, ceea ce este scump și fragil. De aceea, când proiectezi un contract, te gândești din prima la ce events vor avea nevoie front-end-ul și analiza de date.

Datele din indexer sunt o copie derivată; pentru decizii critice (de exemplu un sold înainte de o plată) verifici direct on-chain.

Ce urmărește intervievatorul: Se verifică dacă înțelegi arhitectura unei aplicații reale, dincolo de contract. Greșeala tipică: a propune bucle on-chain sau interogări masive din browser.

93 Senior

Descrie arhitectura unei aplicații descentralizate complete, de la contract la interfață, și deciziile importante pe care le iei.

Răspuns scurt: O dApp tipică are contracte on-chain (sursa de adevăr), acces prin noduri RPC, un indexer pentru istoric, eventual un backend pentru funcții off-chain și un front-end care cere semnături prin wallet. Deciziile țin de încredere, disponibilitate, cost și securitate.

Componente și întrebările de design pentru fiecare:

  • Contracte: ce trebuie neapărat on-chain (custodia valorilor, regulile care trebuie să fie verificabile) și ce poate rămâne off-chain? Sunt upgradeable? Cine le administrează? Pe ce rețea, Layer 1 sau Layer 2, în funcție de cost, latență și utilizatori?
  • RPC: cel puțin doi furnizori, cu fallback (FallbackProvider în ethers sau transport fallback în viem), limitare de rată, cache pentru citirile frecvente. Un singur furnizor înseamnă un singur punct de eșec.
  • Indexer: The Graph sau serviciu propriu, cu tratarea reorg-urilor și cu marcarea datelor ne-finalizate.
  • Backend (opțional): emiterea de semnături EIP-712 pentru acțiuni autorizate off-chain, notificări, relayer pentru tranzacții sponsorizate (ERC-4337 paymaster). Cheile lui au privilegii minime și sunt ținute într-un serviciu dedicat de gestiune a cheilor.
  • Front-end: conectarea wallet-ului, simularea tranzacțiilor, afișarea clară a ce semnează utilizatorul, găzduire rezistentă (inclusiv riscul de compromitere a DNS-ului sau a dependențelor npm).
  • Monitorizare: alerte pe events administrative, pe solduri neobișnuite, pe eșecuri ale tranzacțiilor backend-ului.

Compromisuri de discutat:

  • fiecare componentă off-chain adaugă încredere în operator; documentează ce se întâmplă dacă backend-ul cade (ideal, utilizatorii își pot retrage fondurile direct din contract);
  • datele afișate din indexer pot fi în urmă; acțiunile critice se bazează pe starea on-chain;
  • costul pentru utilizator: câte tranzacții face pentru un flux și cât gas consumă.

Un răspuns de senior desenează fluxul unei operații de la clic până la confirmare și arată unde poate eșua fiecare pas.

Ce urmărește intervievatorul: La senior se verifică viziunea de sistem și gândirea pe moduri de eșec. Greșeala tipică: o arhitectură care depinde complet de un singur RPC sau de un backend, fără a recunoaște asta.

Comportamentale și HR

94 Junior

De ce vrei să lucrezi ca Blockchain Developer?

Răspuns scurt: Un răspuns bun leagă motivația de partea tehnică și de proiecte concrete: interesul pentru sisteme distribuite, criptografie și cod care gestionează valoare în mod transparent, plus ce ai construit deja. Evită motivațiile legate de prețul monedelor sau de câștiguri rapide.

Structură recomandată, în trei părți:

  • Ce te atrage tehnic: de exemplu, faptul că un smart contract este cod public, verificabil, care trebuie să fie corect din prima, pentru că nu poți repara ușor după deploy. Sau interesul pentru criptografie aplicată și sisteme distribuite.
  • Dovada: ce ai construit. „Am făcut un vault ERC-20 cu teste Foundry, inclusiv fuzzing, l-am deployat pe Sepolia și am construit un mic front-end cu ethers.js.” Un repository pe care îl poți arăta valorează mai mult decât orice declarație.
  • Legătura cu firma: ce produs construiesc și de ce te interesează acel tip de problemă (plăți, tokenizare, infrastructură, instrumente pentru developeri).

Exemplu de răspuns:

Mă atrage faptul că în blockchain codul e public și ține valoare, deci calitatea și securitatea
contează din prima zi. În ultimele luni am construit un contract de staking cu teste Foundry
și am căutat singur vulnerabilități în el. Vreau să lucrez într-o echipă unde pot învăța audit
și design de protocol, iar produsul vostru de plăți pe Layer 2 este exact genul de problemă
care mă interesează.

Ce să eviți:

  • „Am câștigat bani din crypto și vreau să lucrez în domeniu”: semnalează interes pentru speculație, nu pentru inginerie;
  • opinii despre ce monede vor crește; nu este rolul unui developer și pare neprofesionist;
  • răspunsuri generice, valabile pentru orice domeniu.

Dacă vii din alt domeniu (web, backend, QA), spune ce aduci de acolo: experiența cu testarea, cu API-urile sau cu sistemele de producție este direct utilă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă motivația ta este tehnică și durabilă. Greșeala tipică: a vorbi despre investiții sau prețuri în loc de inginerie.

95 Junior

Prezintă un proiect blockchain pe care l-ai construit. Ce ai face diferit acum?

Răspuns scurt: Folosește o structură clară: problema, soluția și arhitectura, contribuția ta exactă, cum ai testat și ce securitate ai avut în vedere, rezultatul, apoi lecțiile învățate. Partea cu „ce aș face diferit” arată maturitate, deci pregătește-o la fel de bine ca restul.

Intervievatorii folosesc această întrebare ca să vadă cât de adânc înțelegi ce ai făcut. Pregătește un proiect pe care îl poți explica în 3-4 minute și pe care îl poți apoi detalia.

Structură:

  • Problema: ce rezolvă proiectul, pentru cine. „O platformă de vot pentru un club studențesc, cu rezultate verificabile.”
  • Arhitectura: contractele, rețeaua, front-end-ul, eventual indexer-ul. De ce ai ales așa.
  • Contribuția ta: la un proiect de echipă, spune exact ce ai scris tu.
  • Testare și securitate: ce teste ai, ce acoperire, ce vulnerabilități ai luat în calcul (reentrancy, control de acces, front-running la vot), ce unelte ai rulat.
  • Rezultat: unde este deployat, cine l-a folosit, link spre cod.
  • Lecții: ce ai face diferit.

Exemple bune de „ce aș face diferit”:

  • „Aș folosi commit-reveal la vot, pentru că am realizat că voturile erau vizibile în mempool înainte de închidere.”
  • „Aș scrie invarianți de la început, nu teste unitare adăugate la final.”
  • „Aș emite mai multe events; front-end-ul a ajuns să citească storage-ul în bucle.”

Așteaptă-te la întrebări de detaliu: „De ce uint96 aici?”, „Ce se întâmplă dacă proprietarul își pierde cheia?”, „Cât costă în gas un vot?”. Dacă nu știi un răspuns, spune ce ai verifica și cum, în loc să inventezi.

Ca junior, un proiect personal bine testat, cu README clar și deploy pe testnet, contează mult. Un proiect copiat dintr-un tutorial, fără modificări proprii, se observă repede la întrebările de detaliu.

Ce urmărește intervievatorul: Se verifică profunzimea înțelegerii și capacitatea de autoevaluare. Greșeala tipică: a descrie tehnologiile folosite fără a explica deciziile și compromisurile.

96 Junior

Cum te ții la curent cu schimbările din ecosistemul blockchain?

Răspuns scurt: Răspunsul bun numește surse tehnice primare și un obicei concret: EIP-urile și notele de upgrade ale rețelelor, changelog-urile Solidity și ale bibliotecilor, rapoarte de audit și analize post-incident, plus practică proprie (CTF-uri de securitate, contribuții open source). Arată și cum filtrezi zgomotul.

Ecosistemul se schimbă repede: upgrade-uri de rețea care modifică opcode-uri și costuri, versiuni noi de Solidity, OpenZeppelin cu schimbări de API între versiuni majore, unelte noi. Intervievatorul vrea să vadă că ai un sistem, nu că citești doar titluri.

Surse de menționat:

  • EIP-uri și notele oficiale ale upgrade-urilor Ethereum (de exemplu Dencun, Pectra) pe blogul Ethereum Foundation;
  • release notes pentru Solidity, OpenZeppelin Contracts, Foundry, Hardhat, ethers sau viem;
  • rapoarte de audit publice și analize post-incident (post-mortem). Sunt probabil cea mai eficientă sursă de învățare pentru securitate;
  • platforme de concursuri de audit și programe de bug bounty, unde poți citi constatările altora;
  • exerciții practice de tip CTF pentru smart contracts, precum Ethernaut sau Damn Vulnerable DeFi.

Cum să structurezi răspunsul:

Urmăresc release notes pentru Solidity și OpenZeppelin, pentru că afectează direct codul.
Săptămânal citesc cel puțin un raport de audit sau un post-mortem și încerc să reproduc
problema într-un test Foundry. Când apare un upgrade de rețea, citesc EIP-urile care schimbă
EVM-ul. Ultimul lucru învățat așa a fost transient storage din EIP-1153.

Un exemplu concret recent face răspunsul credibil. Evită să enumeri doar influenceri sau canale cu știri de piață: un rol de developer se bazează pe surse tehnice. Dacă participi la comunități locale sau online de developeri, menționează-le, mai ales dacă ai contribuit cu ceva.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înveți activ și din surse de calitate. Greșeala tipică: răspunsuri vagi sau surse orientate spre prețuri, nu spre tehnologie.

97 Mid

Povestește despre cel mai greu bug pe care l-ai depanat într-un contract sau într-o dApp.

Răspuns scurt: Folosește metoda STAR (situație, sarcină, acțiune, rezultat) și insistă pe procesul de investigare: cum ai reprodus problema, ce ipoteze ai testat, ce unelte ai folosit (trace-uri, fork, teste) și ce ai schimbat ca să nu se mai repete.

Structură STAR adaptată:

  • Situație: contextul, pe scurt. „Pe testnet, unii utilizatori nu își puteau retrage recompensele, alții da.”
  • Sarcină: ce trebuia să faci și ce miză era. „Trebuia să găsesc cauza înainte de lansare.”
  • Acțiune: partea cea mai lungă. Pașii concreți.
  • Rezultat: ce s-a rezolvat și ce s-a schimbat în proces.

Exemplu de acțiune bine povestită:

Am luat hash-ul unei tranzacții eșuate și am rulat trace-ul complet cu `cast run`. Am văzut
un Panic 0x11 (overflow aritmetic) în calculul recompensei. Am reprodus pe un fork la acel
bloc, apoi am scris un fuzz test pe funcția de calcul. Fuzzer-ul a găsit că pentru utilizatorii
care depuseseră înainte de o schimbare de parametru, o diferență devenea negativă. Am corectat
ordinea actualizării indexului de recompense și am adăugat un invariant ca suma recompenselor
plătite să nu depășească fondul alocat.

Ce vrea să audă intervievatorul:

  • că reproduci întâi, înainte să modifici cod;
  • că folosești unelte potrivite: trace-uri (cast run, Tenderly), loguri (console.log din forge-std sau Hardhat), teste pe fork;
  • că treci de la simptom la cauza de fond;
  • că adaugi un test care ar fi prins problema și, eventual, schimbi procesul.

Dacă nu ai un bug în smart contracts, alege unul din alt proiect software și leagă lecția de blockchain. Fii sincer: inventarea unei povești se observă la întrebările de detaliu.

Ce urmărește intervievatorul: Se verifică metoda de depanare și onestitatea. Greșeala tipică: povești în care problema „s-a rezolvat” fără a explica cum a fost găsită cauza.

98 Mid

Cum îi explici unui product manager că o funcționalitate cerută este riscantă sau prea scumpă în gas?

Răspuns scurt: Traduci problema tehnică în impact pentru produs și pentru utilizatori (cost per acțiune, risc de pierdere de fonduri, imposibilitatea de a corecta după lansare), vii cu cel puțin o alternativă concretă și lași decizia să fie luată informat, nu impusă de tine.

Situație tipică: PM-ul vrea ca la fiecare acțiune să se calculeze și să se plătească automat recompense pentru toți utilizatorii, on-chain.

Structură de răspuns:

  • Înțelegi scopul: ce problemă de business vrea să rezolve? Poate „utilizatorii să vadă imediat recompensele”.
  • Explici impactul în termeni de produs: „Fiecare utilizator nou face tranzacția mai scumpă. La câteva mii de utilizatori, operația devine prea scumpă sau imposibil de executat într-un bloc, iar funcționalitatea se blochează.”
  • Riști cuantificat, fără cifre inventate: estimezi cu un test de gas și arăți rezultatul real din raport, nu aproximezi din memorie.
  • Propui alternative: model pull, în care fiecare își revendică recompensa; calcul off-chain cu Merkle root; afișarea recompenselor acumulate în UI din indexer, fără plată automată.
  • Lași decizia la masă: prezinți compromisurile fiecărei variante (cost, complexitate, încredere în operator, termen).

Pentru riscuri de securitate, adaugi un argument specific domeniului: un contract deployat nu se poate corecta la fel de ușor ca un site, iar o eroare poate însemna pierderi pentru utilizatori. De aceea unele funcționalități cer audit sau timp suplimentar de testare.

Exemplu de formulare:

Pot construi varianta cerută, dar testele arată că plata automată devine nefezabilă pe măsură ce
crește numărul de utilizatori. Propun ca utilizatorii să-și revendice recompensa cu un clic, iar
UI-ul să afișeze suma acumulată în timp real. Experiența rămâne aproape aceeași, iar riscul scade.

Ideea centrală: nu spui doar „nu se poate”, ci „uite ce se poate și cu ce cost”.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți colabora cu oameni non-tehnici și dacă propui soluții. Greșeala tipică: refuz tehnic fără alternative sau fără explicații pe înțelesul celuilalt.

99 Senior

Descoperi o vulnerabilitate gravă într-un contract deja în producție, care deține fondurile utilizatorilor. Ce faci?

Răspuns scurt: Nu faci problema publică. Anunți imediat, pe un canal privat, persoanele responsabile, confirmi exploatabilitatea și gravitatea, activezi mecanismele de urgență (pauză, limitare), testezi remedierea pe fork și comunici transparent după ce riscul a fost redus.

Pași, în ordine:

  • Confidențialitate: nu discuți în canale publice, issue-uri GitHub sau chat-uri largi. Tranzacțiile de remediere pot fi și ele observate în mempool, deci și ele pot dezvălui problema.
  • Escaladare: informezi conform procedurii echipei (responsabilul de securitate, CTO-ul, semnatarii multisig-ului). Dacă nu există procedură, este o constatare în sine.
  • Evaluare: scrii rapid un proof of concept pe un fork de mainnet ca să confirmi exploatabilitatea, impactul (ce fonduri sunt în pericol) și condițiile.
  • Atenuare: activezi pauza sau limitele, dacă există. Dacă fondurile pot fi mutate în siguranță, unele echipe fac un „white hat rescue”, dar numai cu coordonare și cu tranzacții trimise privat, ca să nu fie copiate de bots.
  • Remediere: corectura este revizuită de cel puțin încă o persoană și, ideal, de un auditor extern, apoi testată pe fork cu starea reală, inclusiv pe scenariul de atac.
  • Comunicare: după ce riscul a fost înlăturat, publici o analiză post-incident: ce s-a întâmplat, impactul, ce s-a schimbat.
  • Prevenție: test de regresie, revizuirea codului similar, actualizarea procesului.

Dacă vulnerabilitatea este în protocolul altcuiva, folosești programul lor de bug bounty sau contactul de securitate (de exemplu un fișier SECURITY.md) și urmezi principiile de responsible disclosure. Nu exploatezi vulnerabilitatea „ca să demonstrezi” și nu ceri plată în afara unui program oficial; asta poate fi ilegal și distruge încrederea.

Ce urmărește intervievatorul: La senior se verifică judecata sub presiune și etica profesională. Greșeala tipică: postarea publică a problemei sau trimiterea unei remedieri vizibile în mempool fără coordonare.

100 Senior

Cum gestionezi un dezacord cu un auditor sau cu un coleg senior asupra unei decizii de design?

Răspuns scurt: Separi persoana de argument, înțelegi exact scenariul de risc, aduci dovezi (test, PoC, documentație) și propui criterii comune de decizie. La contracte care țin valoare, varianta mai sigură câștigă de obicei. Documentezi decizia și motivul.

Situație tipică: auditorul marchează ca „medium” faptul că adminul poate schimba oracolul fără timelock. Tu consideri că e nevoie de reacție rapidă în caz de urgență.

Cum procedezi:

  • Asculți și reformulezi: „Înțeleg că riscul este ca o cheie compromisă să schimbe oracolul și să permită lichidări abuzive, corect?” Confirmi că ați vorbit despre același scenariu.
  • Argumentezi cu dovezi: un test care arată comportamentul, constrângerile operaționale reale, exemple din documentația standardelor sau din alte protocoale auditate.
  • Cauți o soluție care satisface ambele griji: timelock pentru schimbarea oracolului, dar un rol de pauză rapidă pentru urgențe. De multe ori, dezacordul dispare când separi cele două nevoi.
  • Criterii comune: impactul asupra utilizatorilor, probabilitatea, costul de implementare, reversibilitatea.
  • Decizia și documentarea: dacă echipa acceptă un risc, o face explicit, în scris, cu motivația. În răspunsul către auditor scrii „acknowledged” cu explicație, nu ignori constatarea.

Exemplu:

Nu am fost de acord inițial cu o recomandare de audit, pentru că ar fi întârziat reacția la
incidente. Am cerut un apel, am înțeles exact scenariul, și am ajuns la un compromis:
timelock pe schimbarea parametrilor, plus un rol separat doar pentru pauză. Decizia a intrat
în documentația de risc a protocolului.

Atitudinea contează: un auditor nu este adversarul tău, ci o a doua pereche de ochi. Dacă nu poți demonstra că un risc nu există, presupune că există.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea profesională și raportarea la critică. Greșeala tipică: a trata constatările de audit ca atacuri personale sau a le respinge fără argumente.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Blockchain Developer

← 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 Developer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Blockchain Developer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.