...
Pregătire interviuri

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

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

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

  • 100întrebări
  • 48junior
  • 37mid
  • 15senior
  • 139 minde citit
Întrebări de interviu Solidity cu răspunsuri

La un interviu în care se verifică Solidity, discuția trece repede de la teorie la cod. Intervievatorul pune pe ecran un contract scurt și te întreabă ce face, ce costă, unde e bug-ul sau cum ar putea fi atacat. Se verifică detaliile limbajului (tipuri, locația datelor, vizibilitate, erori, trimiterea de ether), standardele de tokeni și bibliotecile OpenZeppelin, optimizarea gazului și, mai ales, securitatea. Adesea urmează o temă pentru acasă: un contract mic, cu teste în Foundry sau Hardhat, unde contează la fel de mult testele și cazurile limită cât și codul.

La nivel junior se așteaptă să citești corect cod Solidity 0.8.x: ce valoare are o variabilă neinițializată, ce se întâmplă la un revert, ce funcție primește ether-ul, cum arată un mint sau un burn. La nivel mid se adaugă apelurile de nivel jos, contractele upgradeable, aprobările, tehnicile de gaz și tiparele de vulnerabilități pe care le recunoști direct în cod. La nivel senior intervin rotunjirile în favoarea protocolului, atacurile pe guvernanță, regula 63/64, stocarea namespaced și deciziile de lansare și monitorizare.

Pagina conține 100 de întrebări grupate pe teme, de la junior la senior în fiecare temă. Încearcă să răspunzi singur înainte să citești răspunsul și rulează exemplele într-un proiect Foundry (forge test -vvvv), modificându-le până înțelegi de ce se comportă așa. Răspunsul scurt e ce spui în primele secunde, iar cel detaliat arată cât de adânc poate merge discuția. Întrebările generale despre blockchain, EVM, consens, ethers.js și arhitectura unei dApp sunt pe pagina dedicată meseriei de Blockchain Developer.

Tipuri, valori și unități

1 Junior

Ce valori au variabilele de mai jos imediat după deploy? De ce în Solidity nu există null sau undefined?

SOLIDITY
contract Defaults {
    uint256 public a;
    bool public b;
    address public c;
    string public d;
    bytes32 public e;
    mapping(address => uint256) public m;
}

Răspuns scurt: a este 0, b este false, c este address(0), d este șirul gol, e are 32 de octeți zero, iar m(x) întoarce 0 pentru orice cheie. EVM pornește tot storage-ul de la zero, deci fiecare tip are o valoare implicită.

Storage-ul unui contract este o hartă uriașă de sloturi de 32 de octeți, iar orice slot necitit sau nescris conține zero. Compilatorul interpretează acest zero după tip: pentru uint și int e 0, pentru bool e false, pentru address e address(0), pentru bytes32 sunt 32 de octeți 0x00, pentru string și bytes dinamice e lungime 0, pentru un enum e primul membru. Același lucru e valabil pentru variabilele locale din memory.

De aceea nu există null: nu există un „nimic” separat de valoarea zero. Consecința practică e că nu poți distinge între „nu a fost setat” și „a fost setat la zero”:

SOLIDITY
mapping(address => uint256) public balances;
// balances[alice] == 0 poate însemna: n-a depus niciodată
// sau a depus și a retras tot. Contractul nu știe diferența.

Când diferența contează, păstrezi explicit o informație în plus: un mapping(address => bool) registered, un câmp exists într-un struct sau un indice salvat cu +1, ca 0 să însemne „lipsă”.

Mai e o capcană: address(0) e o valoare validă de tip, deci o funcție setOwner(address(0)) va compila și va rula. Codul de producție verifică explicit if (newOwner == address(0)) revert ZeroAddress(); acolo unde zero ar bloca contractul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că storage-ul pornește de la zero și ce implică asta pentru logică. Greșeala tipică e să tratezi 0 ca „neinițializat” fără un flag separat.

2 Junior

Ce se întâmplă în fiecare caz, în Solidity 0.8.x?

SOLIDITY
uint256 x = 300;
uint8 a = uint8(x);
uint8 b = uint8(300);
int256 n = -1;
uint256 c = uint256(n);

Răspuns scurt: a devine 44, fără revert: conversia explicită la un tip mai mic taie biții de sus. uint8(300) nu compilează, pentru că literalul nu încape. c devine valoarea maximă a lui uint256, pentru că biții lui -1 sunt reinterpretați.

Verificarea de overflow din Solidity 0.8 se aplică doar operațiilor aritmetice (+, -, *, /, **, ++), nu și conversiilor explicite. O conversie explicită către un tip mai mic păstrează doar biții de jos: 300 este 0x012C, iar uint8 păstrează 0x2C, adică 44.

Cu literali, compilatorul știe valoarea și refuză uint8(300) cu eroare de tip. Cu variabile, nu are cum, deci conversia trece silențios la runtime.

Conversia între tipuri cu semn și fără semn, de aceeași dimensiune, reinterpretează biții: -1 în complement față de doi înseamnă toți biții 1, deci uint256(int256(-1)) == type(uint256).max. Din 0.8.0 nu mai poți schimba în același pas și dimensiunea, și semnul (uint8(int256(x)) nu compilează); trebuie două conversii.

În cod real, bug-ul apare când împachetezi valori pentru a economisi gaz:

SOLIDITY
struct Stake { uint96 amount; uint32 since; }
stakes[msg.sender].amount = uint96(amount); // dacă amount > 2^96 - 1, se pierde

Soluția standard este SafeCast din OpenZeppelin, care dă revert dacă valoarea nu încape:

SOLIDITY
using SafeCast for uint256;
stakes[msg.sender].amount = amount.toUint96();

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă știi limita protecției din 0.8. Mulți candidați cred că și conversiile explicite dau revert la depășire.

Eroarea, în practică:uint256 is not implicitly convertible to uint8Cannot implicitly convert signed literal to unsigned

3 Junior

Ce întorc expresiile următoare și de ce contează pentru calcule cu bani?

SOLIDITY
uint256 a = 7 / 2;
int256 b = -7 / 2;
int256 c = -7 % 2;
uint256 d = 5 / 10 * 100;
uint256 e = 5 * 100 / 10;

Răspuns scurt: a este 3, b este -3, c este -1, d este 0 și e este 50. Solidity are doar împărțire întreagă care rotunjește spre zero, deci ordinea operațiilor schimbă rezultatul.

Solidity nu are numere zecimale (tipurile fixed există în specificație, dar nu pot fi folosite). Împărțirea între întregi taie partea fracționară, rotunjind spre zero: 7 / 2 este 3, iar -7 / 2 este -3, nu -4. Restul % are semnul operandului din stânga, deci -7 % 2 este -1.

Ordinea contează enorm: 5 / 10 este deja 0, iar 0 înmulțit cu orice rămâne 0. Dacă înmulțești întâi și împarți la final, păstrezi precizia:

SOLIDITY
// greșit: pierde tot sub 1%
uint256 fee = amount / 100 * feePercent;
// corect: înmulțirea întâi
uint256 fee = amount * feePercent / 100;

Alte detalii:

  • împărțirea la zero și % 0 dau revert cu Panic(0x12), chiar și în bloc unchecked;
  • type(int256).min / -1 dă overflow și revert în modul verificat;
  • pentru produse mari care ar depăși uint256 înainte de împărțire, folosești Math.mulDiv(a, b, c) din OpenZeppelin, care calculează a * b / c cu precizie completă.

Regula de interviu: înmulțiri întâi, o singură împărțire la final, și gândește explicit în ce direcție rotunjești (de obicei în favoarea contractului, nu a utilizatorului).

Ce urmărește intervievatorul: Se verifică înțelegerea aritmeticii întregi, sursa multor bug-uri de calcul. Greșeala tipică e împărțirea înaintea înmulțirii.

Eroarea, în practică:rational_const is not implicitly convertible

4 Junior

De ce codul următor nu compilează în Solidity 0.8 și cum îl repari? Care e diferența dintre address și address payable?

SOLIDITY
function refund() external {
    msg.sender.transfer(1 ether);
}

Răspuns scurt: Din 0.8.0, msg.sender are tipul address, nu address payable, iar transfer și send există doar pe address payable. Repari cu payable(msg.sender).transfer(...) sau, mai bine, cu call.

Ambele tipuri țin aceeași valoare de 20 de octeți. Diferența e de tip, la compilare: address payable are în plus membrii transfer și send, prin care contractul trimite ether. Separarea există ca să nu trimiți ether din greșeală la o adresă care nu ar trebui să primească.

Membrii comuni ambelor: balance, code, codehash, call, delegatecall, staticcall.

Conversiile:

SOLIDITY
address a = msg.sender;
address payable p = payable(a);   // explicit
address b = p;                    // implicit, invers merge
address payable self = payable(address(this));

Un contract poate fi convertit direct la address payable doar dacă are receive sau fallback payable; altfel treci prin address(...) întâi.

Varianta recomandată astăzi pentru trimitere nu e nici transfer, nici send, ci:

SOLIDITY
(bool ok, ) = payable(msg.sender).call{value: 1 ether}("");
if (!ok) revert TransferFailed();

transfer transmite doar 2300 de gaz, ceea ce poate face plata să eșueze către portofele-contract. Folosind call trebuie însă să aplici tiparul checks-effects-interactions, pentru că destinatarul primește tot gazul și poate reintra în contract.

Ce urmărește intervievatorul: Se verifică dacă ai scris cod pe 0.8 sau doar ai citit tutoriale vechi. Mulți candidați nu știu că msg.sender nu mai e payable.

Eroarea, în practică:address not convertible to address payablesend and transfer only for address payable

5 Junior

Care e diferența dintre string, bytes și bytes32? Cum compari două string-uri în Solidity?

Răspuns scurt: string și bytes sunt dinamice și stochează octeți arbitrari (string e UTF-8, fără acces la caractere), iar bytes32 are lungime fixă și încape într-un slot. Comparația se face prin hash: keccak256(bytes(a)) == keccak256(bytes(b)).

string e de fapt bytes cu o promisiune de UTF-8, dar fără funcții de manipulare: nu are length, nu poți accesa s[0] și nu poți folosi ==. Ca să lucrezi cu el îl convertești la bytes:

SOLIDITY
function len(string memory s) public pure returns (uint256) {
    return bytes(s).length; // numărul de octeți, nu de caractere
}

Atenție: len("ș") întoarce 2, pentru că ș ocupă doi octeți în UTF-8.

bytes e un array dinamic de octeți, cu length, index și push (în storage). E mai eficient decât bytes1[], care ar irosi spațiu.

bytes1 până la bytes32 sunt tipuri valoare de lungime fixă. bytes32 încape într-un singur slot și se compară direct cu ==, de aceea e preferat pentru identificatori, hash-uri și roluri (keccak256("MINTER_ROLE")).

Compararea string-urilor:

SOLIDITY
function eq(string memory a, string memory b) internal pure returns (bool) {
    return keccak256(bytes(a)) == keccak256(bytes(b));
}

Pentru concatenare există string.concat(a, b) (din 0.8.12) și bytes.concat. În general, contractele evită logica pe string-uri: costă gaz și e mai bine să fie făcută off-chain, în aplicație.

Ce urmărește intervievatorul: Se verifică dacă știi limitele tipurilor de text. Greșeala tipică e să crezi că bytes(s).length dă numărul de caractere.

Eroarea, în practică:operator == cannot be applied to stringkeccak256: requires a single bytes argument

6 Junior

Care e diferența dintre constant și immutable? Ce variantă alegi pentru fiecare variabilă de mai jos?

SOLIDITY
contract Token {
    uint256 ??? MAX_SUPPLY = 1_000_000e18;
    address ??? treasury;
    uint256 ??? deployedAt;
    constructor(address t) { treasury = t; deployedAt = block.timestamp; }
}

Răspuns scurt: constant primește valoarea la compilare, immutable o primește o singură dată, în constructor. Aici MAX_SUPPLY e constant, iar treasury și deployedAt sunt immutable. Niciuna nu ocupă un slot de storage.

Ambele elimină citirea din storage (SLOAD, 2100 de gaz la prima citire dintr-o tranzacție), pentru că valoarea ajunge direct în bytecode.

  • constant: valoarea trebuie să fie cunoscută la compilare (literal sau expresie constantă, de exemplu keccak256("ADMIN")). Compilatorul o copiază în fiecare loc unde e folosită. Merge pentru tipuri valoare și pentru string.
  • immutable: valoarea se atribuie în constructor și nu se mai poate schimba. Compilatorul rezervă locuri în bytecode-ul final și le completează la deploy. Merge doar pentru tipuri valoare (nu string, nu array-uri).
SOLIDITY
uint256 public constant MAX_SUPPLY = 1_000_000e18;
address public immutable treasury;
uint256 public immutable deployedAt;

Convenția e ca numele să fie scrise cu majuscule pentru constant și uneori și pentru immutable (TREASURY).

Detaliu important pentru contractele upgradeable: proxy-ul execută codul implementării prin delegatecall, deci un immutable setat în constructorul implementării e același pentru toate proxy-urile și nu poate fi schimbat la inițializare. E acceptabil pentru valori cu adevărat fixe (de exemplu adresa unui contract de sistem), dar nu pentru setări per instanță.

Dacă o valoare trebuie să se poată schimba ulterior, de exemplu un comision, rămâne variabilă de stare normală, cu o funcție de administrare protejată.

Ce urmărește intervievatorul: Se verifică dacă știi când valoarea e fixată și ce economisește fiecare. Candidații confundă des cele două sau cred că immutable acceptă și string.

Eroarea, în practică:Cannot assign to a constant variableCannot write to immutable here

7 Junior

Ce afișează funcțiile de mai jos? Ce se întâmplă la Status(5)?

SOLIDITY
enum Status { Pending, Active, Closed }
Status public s;

function a() external view returns (uint8) { return uint8(s); }
function b() external pure returns (uint8) { return uint8(type(Status).max); }
function c(uint8 x) external pure returns (Status) { return Status(x); }

Răspuns scurt: a() întoarce 0, pentru că valoarea implicită e primul membru, Pending. b() întoarce 2. c(5) dă revert cu Panic(0x21), pentru că 5 nu corespunde niciunui membru.

Un enum e un tip propriu cu valori numite, reprezentat intern ca uint8 (poate avea cel mult 256 de membri). Membrii primesc valori de la 0, în ordinea declarării. Pentru că storage-ul pornește de la zero, primul membru este și valoarea implicită: de aceea e bine ca primul membru să fie o stare „neutră” (None, Pending), nu una cu efecte.

type(Status).min și type(Status).max există din 0.8.8 și dau primul și ultimul membru.

Conversia din întreg în enum e verificată la runtime: o valoare în afara intervalului dă revert cu Panic(0x21). Conversia în sens invers, uint8(Status.Active), e întotdeauna sigură.

Folosire tipică, ca mașină de stări:

SOLIDITY
enum Phase { Setup, Open, Closed }
Phase public phase;

modifier inPhase(Phase p) {
    if (phase != p) revert WrongPhase(phase, p);
    _;
}

function open() external onlyOwner inPhase(Phase.Setup) { phase = Phase.Open; }

În ABI, un enum apare ca uint8, deci front-end-ul primește un număr și trebuie să cunoască ordinea membrilor. De aici o regulă la contractele upgradeable: nu reordonezi și nu ștergi membri, doar adaugi la final, altfel valorile deja salvate își schimbă sensul.

Ce urmărește intervievatorul: Se verifică dacă știi reprezentarea enum-urilor și valoarea lor implicită. Greșeala tipică e să pui ca prim membru o stare „activă” care devine automat valoarea oricărui element nou.

Eroarea, în practică:panic code 0x21 (enum out of range)

8 Junior

Ce valori au expresiile de mai jos? De ce nu compilează ultima linie?

SOLIDITY
uint256 a = 1 ether;
uint256 b = 2 gwei;
uint256 c = 1 days;
uint256 d = 3 weeks;
uint256 n = 7;
uint256 e = n days;

Răspuns scurt: a este 10^18 (wei), b este 2 * 10^9, c este 86400 (secunde), d este 1814400. Ultima linie nu compilează, pentru că sufixele de unitate se pun doar după literali; corect este n * 1 days.

Solidity are sufixe pentru două tipuri de unități, care sunt simple înmulțiri cu o constantă:

  • ether: wei (1), gwei (10^9), ether (10^18). finney și szabo au fost eliminate în 0.7.0.
  • timp: seconds, minutes, hours, days, weeks. years a fost eliminat în 0.5.0, pentru că un an nu are mereu același număr de secunde.

Toate valorile de ether în contract sunt în wei, iar toate valorile de timp sunt în secunde, la fel ca block.timestamp. Sufixele sunt doar pentru lizibilitate:

SOLIDITY
uint256 public constant LOCK = 30 days;
uint256 public constant MIN_DEPOSIT = 0.01 ether;

function lock(uint256 nDays) external payable {
    if (msg.value < MIN_DEPOSIT) revert TooSmall();
    unlockAt[msg.sender] = block.timestamp + nDays * 1 days;
}

Poți scrie literali cu zecimale dacă rezultatul e întreg: 0.01 ether e valid (10^16 wei), dar 0.5 wei nu. Separatorul _ ajută la citire: 1_000_000.

La interviu apare frecvent și conversia în aplicație: în ethers v6, parseEther("0.01") dă 10000000000000000n (un bigint), iar formatEther face invers. O confuzie între wei și ether într-un test sau într-un script de deploy poate trimite de 10^18 ori mai mult sau mai puțin decât intenționai.

Ce urmărește intervievatorul: Se verifică familiaritatea cu unitățile și cu faptul că totul e în wei și secunde. Mulți candidați încearcă să pună days după o variabilă.

Eroarea, în practică:Using "years" as a unit denomination is deprecated

9 Junior

Ce variabile globale folosești des într-un contract și ce poți și ce nu poți afla din ele? Explică block.chainid, msg.data, msg.sig, gasleft() și blockhash.

Răspuns scurt: msg.* descrie apelul curent (expeditor, valoare, date), block.* descrie blocul (timp, număr, chainId, baseFee), iar tx.* descrie tranzacția. gasleft() dă gazul rămas, iar blockhash(n) merge doar pentru ultimele 256 de blocuri.

Cele mai folosite:

  • msg.sender: cine a apelat direct funcția (cont extern sau contract);
  • msg.value: câți wei au venit cu apelul, doar în funcții payable;
  • msg.data: calldata completă, de tip bytes calldata;
  • msg.sig: primii 4 octeți din calldata, adică selectorul funcției;
  • block.timestamp: timpul blocului, în secunde Unix;
  • block.number: numărul blocului;
  • block.chainid (din 0.8.0): identificatorul rețelei, de exemplu 1 pentru mainnet și 11155111 pentru Sepolia;
  • block.basefee (din 0.8.7) și block.prevrandao (din 0.8.18, înlocuiește block.difficulty după The Merge);
  • gasleft(): gazul rămas în apelul curent;
  • blockhash(n): hash-ul blocului n, dar doar pentru ultimele 256 de blocuri; pentru altele întoarce zero.

block.chainid e important la semnături: îl incluzi în mesajul semnat ca o semnătură de pe un lanț să nu fie validă pe altul (EIP-712 îl pune în domain separator).

Ce nu poți afla: data calendaristică exactă (doar timestamp), lista de tranzacții din bloc, prețul unui token, orice dată din afara lanțului. Pentru date externe ai nevoie de un oracol.

Valorile din block.* sunt cunoscute de cel care produce blocul și sunt publice înainte de execuție, deci nu sunt surse de aleatoriu. Pe L2-uri unele (de exemplu block.number) pot avea alt sens decât pe Ethereum, așa că verifici documentația rețelei.

Ce urmărește intervievatorul: Se verifică dacă știi ce context ai la dispoziție în contract. Greșeala tipică e să te bazezi pe blockhash pentru blocuri vechi, unde întoarce zero.

Eroarea, în practică:"now" has been deprecated

10 Mid

Unde e bug-ul în funcția de mai jos, folosită ca cheie unică pentru o înregistrare?

SOLIDITY
function key(string memory first, string memory last) public pure returns (bytes32) {
    return keccak256(abi.encodePacked(first, last));
}

Răspuns scurt: abi.encodePacked lipește string-urile fără lungimi, deci key("ab", "c") și key("a", "bc") dau același hash. Cu două sau mai multe argumente dinamice folosești abi.encode, care include offset-urile și lungimile.

abi.encode produce codificarea ABI standard: fiecare valoare ocupă cel puțin 32 de octeți, iar tipurile dinamice (string, bytes, array-uri) sunt precedate de offset și lungime. Rezultatul e lung, dar fără ambiguitate.

abi.encodePacked produce o codificare compactă: tipurile statice folosesc doar câți octeți au nevoie, iar tipurile dinamice sunt puse direct, fără lungime. Asta înseamnă că "ab" + "c" și "a" + "bc" produc aceiași octeți, 0x616263, deci același hash.

Unde devine vulnerabilitate:

  • chei într-un mapping, unde un atacator poate suprascrie înregistrarea altcuiva;
  • mesaje semnate: un utilizator semnează ("ab", "c"), iar atacatorul folosește semnătura pentru ("a", "bc");
  • array-uri dinamice în encodePacked, unde granița dintre ele se poate muta.

Repararea:

SOLIDITY
return keccak256(abi.encode(first, last));

encodePacked rămâne în regulă când ai cel mult un singur argument dinamic sau doar tipuri statice (de exemplu abi.encodePacked(address, uint256)), deși și acolo mulți preferă abi.encode pentru claritate. Instrumentele de analiză statică, precum Slither, semnalează automat encodePacked cu mai multe argumente dinamice.

Ce urmărește intervievatorul: Se verifică dacă cunoști diferența dintre cele două codificări și riscul de coliziune. E o capcană clasică în audituri și în semnături.

Eroarea, în practică:keccak256: requires a single bytes argument

11 Mid

Un protocol percepe un comision de 0,3% și calculează recompense cu 18 zecimale. Scrie calculul corect și explică ce e greșit aici:

SOLIDITY
uint256 fee = amount / 1000 * 3;
uint256 rewardPerToken = totalReward / totalStaked;

Răspuns scurt: Prima linie pierde precizie, pentru că împarte înainte să înmulțească; corect este amount * 30 / 10_000. A doua dă 0 când totalReward < totalStaked; scalezi cu 1e18: totalReward * 1e18 / totalStaked, apoi împarți la 1e18 la final.

Fără numere zecimale, procentele se exprimă în puncte de bază (basis points, 1 bp = 0,01%), iar fracțiile se scalează cu un factor mare, de obicei 1e18, numit fixed-point.

Comisionul:

SOLIDITY
uint256 public constant FEE_BPS = 30;        // 0,30%
uint256 public constant BPS = 10_000;
uint256 fee = amount * FEE_BPS / BPS;

Cu varianta originală, pentru amount = 999 rezultatul era 0, deci orice sumă sub 1000 de unități nu plătea comision. Un atacator poate împărți o operație mare în multe operații mici ca să evite taxa.

Recompensele:

SOLIDITY
// 1e18 = precizie de 18 zecimale
rewardPerToken += totalReward * 1e18 / totalStaked;
uint256 earned = stake[user] * rewardPerToken / 1e18;

Dacă totalReward e 100 și totalStaked e 1000 de tokeni de 18 zecimale (10^21), împărțirea directă dă 0 și nimeni nu primește nimic. Cu scalare, valoarea intermediară păstrează fracția.

Ce mai verifici:

  • produsul intermediar poate depăși uint256 dacă scalezi de două ori; Math.mulDiv din OpenZeppelin calculează a * b / c fără overflow intermediar;
  • direcția rotunjirii: comisionul se rotunjește în sus în favoarea protocolului (Math.mulDiv(..., Math.Rounding.Ceil)), sumele plătite utilizatorilor în jos;
  • totalStaked == 0 trebuie tratat separat, altfel împarți la zero.

Ce urmărește intervievatorul: Se verifică dacă poți face calcule financiare corecte fără zecimale. Greșeala tipică e împărțirea prematură și ignorarea direcției de rotunjire.

Storage, memory, mapping-uri și array-uri

12 Junior

Când ești obligat să scrii storage, memory sau calldata și de ce un parametru external de tip array e de obicei calldata?

SOLIDITY
function sum(uint256[] ??? values) external pure returns (uint256 s) {
    for (uint256 i; i < values.length; i++) s += values[i];
}

Răspuns scurt: Locația e obligatorie pentru tipurile referință (array-uri, struct-uri, string, bytes) în parametri, valori returnate și variabile locale. Aici alegi calldata: datele se citesc direct din input, fără copiere în memory, deci e mai ieftin, iar funcția nu le modifică oricum.

Tipurile valoare (uint, bool, address, bytesN, enum) se copiază mereu și nu au nevoie de locație. Tipurile referință pot fi mari, așa că trebuie să spui unde trăiesc:

  • storage: datele permanente ale contractului; o variabilă locală storage e o referință (pointer) către ele, iar modificările rămân;
  • memory: zonă temporară, ștearsă la finalul apelului; poate fi modificată;
  • calldata: datele de intrare ale apelului, doar pentru citire.

Pentru sum, calldata evită copierea întregului array în memory. Cu memory, compilatorul ar copia fiecare element, cost care crește liniar cu lungimea. Din 0.6.9, calldata e permis pentru parametrii oricărei funcții, nu doar external, și pentru variabile locale.

Când ai nevoie de memory în loc de calldata:

  • vrei să modifici array-ul în funcție;
  • funcția e apelată intern cu date construite în memory (o funcție internal cu parametru calldata nu poate primi un array din memory).

Restricții de reținut: un mapping poate exista doar în storage; un parametru storage e permis doar în funcții internal și private, și în biblioteci.

SOLIDITY
function _bump(Stake storage s) internal { s.amount += 1; } // modifică direct starea

La interviu, alegerea corectă e de obicei calldata pentru intrări externe, memory pentru valori construite sau returnate și storage pentru referințe la starea contractului.

Ce urmărește intervievatorul: Se verifică dacă știi regulile locației datelor și impactul pe gaz. Mulți candidați pun memory peste tot din obișnuință.

Eroarea, în practică:Data location must be "memory" or "calldata"Data location must be "storage", "memory"...

13 Junior

De ce nu compilează funcția de mai jos și cum o rescrii ca să întoarcă doar numerele pare din input?

SOLIDITY
function evens(uint256[] calldata xs) external pure returns (uint256[] memory out) {
    for (uint256 i; i < xs.length; i++) {
        if (xs[i] % 2 == 0) out.push(xs[i]);
    }
}

Răspuns scurt: Array-urile din memory au lungime fixă după creare și nu au push; push și pop există doar pentru array-uri dinamice din storage. Numeri întâi elementele, aloci cu new uint256[](count), apoi le completezi pe poziții.

În storage, un array dinamic își păstrează lungimea într-un slot și poate crește cu push() sau scădea cu pop(). În memory, un array se alocă o singură dată, cu o lungime dată, și nu mai poate crește. Variabila out din exemplu e chiar un array de lungime 0, iar compilatorul refuză out.push.

Varianta în doi pași:

SOLIDITY
function evens(uint256[] calldata xs) external pure returns (uint256[] memory out) {
    uint256 count;
    for (uint256 i; i < xs.length; i++) {
        if (xs[i] % 2 == 0) count++;
    }
    out = new uint256[](count);
    uint256 j;
    for (uint256 i; i < xs.length; i++) {
        if (xs[i] % 2 == 0) out[j++] = xs[i];
    }
}

Alternativă cu o singură trecere: aloci cât lungimea inputului, completezi, apoi micșorezi lungimea cu assembly (assembly { mstore(out, j) }). E mai ieftin, dar mai puțin lizibil și trebuie folosit cu grijă.

Alte detalii despre array-uri:

  • array fix: uint256[3] memory a = [uint256(1), 2, 3]; (literalul ia tipul primului element, de aici conversia);
  • accesul în afara limitelor dă revert cu Panic(0x32);
  • pop() pe un array gol dă Panic(0x31).

Ce urmărește intervievatorul: Se verifică dacă știi diferența dintre array-urile din storage și cele din memory. Greșeala tipică e să încerci push în memory.

Eroarea, în practică:"push" is not available outside of storageLength has to be placed in parentheses (new)

14 Junior

Vrei să elimini utilizatorul de pe poziția i dintr-un array din storage. Ce face delete users[i] și care sunt alternativele corecte?

Răspuns scurt: delete users[i] doar pune elementul la valoarea zero, iar lungimea rămâne aceeași, deci apare un „gol”. Pentru eliminare reală folosești swap-and-pop (muți ultimul element în locul lui și faci pop, cost constant, ordinea se schimbă) sau deplasezi elementele (ordine păstrată, cost liniar).

delete în Solidity înseamnă „resetează la valoarea implicită”, nu „scoate din listă”. După delete users[2], array-ul are aceeași lungime, iar pe poziția 2 este address(0). Orice cod care iterează trebuie apoi să sară peste goluri.

Swap-and-pop, varianta folosită cel mai des:

SOLIDITY
function remove(uint256 i) external onlyOwner {
    uint256 last = users.length - 1;
    if (i != last) users[i] = users[last];
    users.pop();
}

Costă la fel indiferent de mărimea array-ului, dar schimbă ordinea. Dacă păstrezi și un mapping(address => uint256) indexOf, trebuie să actualizezi indicele elementului mutat, altfel mapping-ul devine inconsistent.

Deplasarea, când ordinea contează:

SOLIDITY
for (uint256 j = i; j < users.length - 1; j++) {
    users[j] = users[j + 1];
}
users.pop();

Costul crește cu numărul de elemente, iar pe un array mare funcția poate depăși limita de gaz a blocului și devine imposibil de apelat. De aceea, în contracte, ordinea se păstrează rar on-chain; dacă aplicația are nevoie de ordine, o reconstruiește din events.

Verifică și i < users.length, altfel users[i] dă revert cu Panic(0x32), iar pe array gol users.length - 1 dă underflow.

Ce urmărește intervievatorul: Se verifică dacă știi ce face de fapt delete și costul fiecărei variante. Mulți candidați cred că delete scurtează array-ul.

Eroarea, în practică:panic code 0x32 (array out-of-bounds)panic code 0x31 (pop on empty array)

15 Junior

Cum verifici dacă o adresă a fost înregistrată într-un mapping(address => uint256) public score, știind că scorul poate fi și 0?

Răspuns scurt: Nu poți, doar din acel mapping: orice cheie nescrisă întoarce 0, la fel ca o cheie scrisă cu 0. Adaugi o informație separată: un mapping(address => bool) registered sau un struct cu câmpul exists.

Un mapping nu are noțiunea de cheie existentă. Pentru orice cheie, slotul se calculează ca keccak256(abi.encode(key, slotMapping)), iar dacă nimeni nu a scris acolo, valoarea e zero. Așadar score[alice] == 0 nu spune dacă Alice a fost înregistrată.

Varianta cu struct:

SOLIDITY
struct Player {
    uint128 score;
    bool exists;
}
mapping(address => Player) public players;

function register() external {
    if (players[msg.sender].exists) revert AlreadyRegistered();
    players[msg.sender] = Player({score: 0, exists: true});
}

Câmpurile uint128 și bool încap împreună într-un slot, deci verificarea nu costă un SLOAD în plus.

Alte variante folosite:

  • un indice salvat cu +1 într-un mapping asociat unui array (indexOf[a] == 0 înseamnă lipsă, altfel poziția e indexOf[a] - 1);
  • o valoare santinelă, dacă domeniul permite (de exemplu un timestamp de înregistrare, care nu poate fi 0 după deploy).

Partea a doua, care apare des în continuarea întrebării: dacă ai nevoie de lista tuturor jucătorilor, mapping-ul nu te ajută, pentru că nu păstrează cheile. Fie emiți un event Registered(address) și construiești lista off-chain, fie păstrezi un array de chei separat.

Ce urmărește intervievatorul: Se verifică înțelegerea faptului că mapping-ul nu știe ce chei are. Greșeala tipică e verificarea score[a] != 0, care eșuează pentru scoruri zero.

16 Junior

Ce getter generează compilatorul pentru mapping-ul de mai jos și cum îl folosești pentru a afla cât poate cheltui spender din banii lui owner?

SOLIDITY
mapping(address => mapping(address => uint256)) public allowance;

Răspuns scurt: Compilatorul generează function allowance(address owner, address spender) external view returns (uint256). Fiecare nivel de mapping devine un parametru, în ordine. Apelezi allowance(owner, spender).

Un mapping imbricat e un mapping ale cărui valori sunt alte mapping-uri. E structura standard pentru relații între două chei: aprobările ERC-20, voturi per propunere și per utilizator, roluri per resursă.

Scriere și citire:

SOLIDITY
function approve(address spender, uint256 amount) external returns (bool) {
    allowance[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
}

Pentru public, compilatorul generează un getter cu câte un parametru pentru fiecare cheie. Pentru un mapping cu struct ca valoare, getter-ul întoarce câmpurile struct-ului ca tuple, dar omite câmpurile de tip array sau mapping.

Cum se calculează slotul: pentru allowance[o][s], cu mapping-ul declarat în slotul p, întâi h = keccak256(abi.encode(o, p)), apoi keccak256(abi.encode(s, h)). Asta explică de ce ordinea cheilor contează: allowance[a][b] și allowance[b][a] sunt valori diferite.

Ce nu poți face: să afli toți spender pentru un owner, să ștergi tot mapping-ul interior dintr-o dată (delete allowance[o] nu compilează pentru mapping-uri) sau să-l returnezi dintr-o funcție. Dacă ai nevoie de liste, le păstrezi separat sau le reconstruiești din events (Approval).

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum se mapează mapping-urile imbricate pe getter și pe storage. Candidații inversează des ordinea cheilor.

Eroarea, în practică:ERC20InsufficientAllowance(spender, ...)

17 Junior

Care sunt modurile de a crea un struct și de a-l modifica direct în storage? Ce face todos.push() fără argumente?

SOLIDITY
struct Todo { string text; bool done; }
Todo[] public todos;

Răspuns scurt: Îl creezi pozițional Todo("a", false), cu nume Todo({text: "a", done: false}) sau gol și completat câmp cu câmp. Pentru modificare iei o referință Todo storage t = todos[i]. todos.push() adaugă un element zero și întoarce o referință storage la el.

Cele trei variante de creare:

SOLIDITY
function add1(string calldata t) external {
    todos.push(Todo(t, false));               // pozițional
}
function add2(string calldata t) external {
    todos.push(Todo({text: t, done: false})); // cu nume, mai clar
}
function add3(string calldata t) external {
    Todo storage n = todos.push();            // element gol, referință
    n.text = t;
}

Varianta cu nume e recomandată când struct-ul are multe câmpuri, pentru că nu depinde de ordinea lor. Varianta cu push() fără argumente e utilă când struct-ul conține un mapping sau un array, care nu pot fi construite în memory și apoi copiate în storage.

Modificarea:

SOLIDITY
function toggle(uint256 i) external {
    Todo storage t = todos[i];
    t.done = !t.done;
}

storage înseamnă că t arată spre datele din contract, deci schimbarea rămâne. Cu memory, s-ar modifica o copie, care dispare la finalul funcției, iar starea ar rămâne neschimbată. Pentru o singură modificare poți scrie direct todos[i].done = true; referința devine utilă când accesezi mai multe câmpuri, pentru că nu recalculează adresa la fiecare acces.

Getter-ul generat pentru todos primește un index și întoarce (string text, bool done), nu tot array-ul.

Ce urmărește intervievatorul: Se verifică fluența în lucrul cu struct-uri și referințe storage. Greșeala tipică e să modifici o copie din memory și să te miri că starea nu se schimbă.

Eroarea, în practică:Struct with a mapping cannot be constructedstruct memory is not convertible to storage pointer

18 Mid

Scrie o structură de date care permite: adăugarea unui membru, eliminarea lui în cost constant, verificarea apartenenței și listarea tuturor membrilor.

Răspuns scurt: Combini un array de chei cu un mapping de la cheie la poziție plus 1. Adaugi cu push, verifici cu mapping-ul, elimini cu swap-and-pop, actualizând poziția elementului mutat. OpenZeppelin oferă exact asta în EnumerableSet.

Un mapping simplu oferă acces rapid, dar nu poate fi parcurs. Un array poate fi parcurs, dar căutarea e liniară. Le combini:

SOLIDITY
contract Members {
    address[] private list;
    mapping(address => uint256) private pos; // poziție + 1; 0 = lipsă

    function add(address a) external onlyOwner {
        if (pos[a] != 0) revert Exists();
        list.push(a);
        pos[a] = list.length;
    }

    function remove(address a) external onlyOwner {
        uint256 p = pos[a];
        if (p == 0) revert Missing();
        uint256 last = list.length;
        if (p != last) {
            address moved = list[last - 1];
            list[p - 1] = moved;
            pos[moved] = p;
        }
        list.pop();
        delete pos[a];
    }

    function contains(address a) external view returns (bool) { return pos[a] != 0; }
    function members() external view returns (address[] memory) { return list; }
}

De ce +1: pentru că 0 e valoarea implicită a mapping-ului și ar fi ambiguu cu poziția 0.

În practică folosești EnumerableSet.AddressSet din OpenZeppelin, care are aceeași implementare, testată: add, remove, contains, length, at, values.

Avertismentul important: members() întoarce tot array-ul. Pentru citiri off-chain e acceptabil, dar dacă un alt contract îl apelează și lista crește nelimitat, apelul poate depăși gazul disponibil. Ordinea elementelor nu e garantată după eliminări.

Ce urmărește intervievatorul: Se verifică dacă poți implementa o structură de date clasică sub constrângerile EVM. Greșeala tipică e să uiți actualizarea poziției elementului mutat la ștergere.

19 Mid

Ce probleme are funcția de mai jos într-un contract care poate avea zeci de mii de comenzi? Cum o rescrii?

SOLIDITY
Order[] public orders;

function getAllOrders() external view returns (Order[] memory) {
    return orders;
}

Răspuns scurt: Copierea întregului array costă gaz proporțional cu mărimea lui. Off-chain, nodul refuză sau eșuează apelul peste limita sa de gaz pentru eth_call, iar on-chain un contract care o apelează poate rămâne fără gaz. Soluția e paginarea și, pentru interfețe, indexarea din events.

O funcție view nu modifică starea, dar asta nu o face gratuită. Când e apelată off-chain prin eth_call, nodul o execută efectiv și numără gazul. Nodurile și furnizorii RPC aplică o limită de gaz și de timp pentru aceste apeluri, deci la o anumită mărime funcția începe să eșueze, iar aplicația care depindea de ea se strică. Când e apelată dintr-o tranzacție, de un alt contract, costul se plătește real și poate depăși limita blocului.

Pentru Order[] cu struct-uri, fiecare element înseamnă mai multe SLOAD, plus copiere în memory, plus codificare ABI. Costul crește liniar și nu are plafon.

Rescrierea cu paginare:

SOLIDITY
function getOrders(uint256 offset, uint256 limit)
    external view returns (Order[] memory page)
{
    uint256 n = orders.length;
    if (offset >= n) return new Order[](0);
    uint256 end = offset + limit > n ? n : offset + limit;
    page = new Order[](end - offset);
    for (uint256 i = offset; i < end; i++) {
        page[i - offset] = orders[i];
    }
}

Front-end-ul cere câte o pagină, iar costul fiecărui apel e limitat de limit.

Mai bine încă, pentru liste afișate în interfață: contractul emite un event la fiecare comandă nouă, iar aplicația sau un indexer construiește lista din events. Contractul păstrează doar ce îi trebuie pentru propria logică.

Ce urmărește intervievatorul: Se verifică dacă știi că funcțiile view au cost și limite. Greșeala tipică e un getter care merge în teste și se strică în producție când datele cresc.

Eroarea, în practică:Transaction ran out of gas

20 Mid

Ce rămâne în storage după delete accounts[user] în codul de mai jos? Cum ai proiecta altfel?

SOLIDITY
struct Account {
    uint256 balance;
    mapping(address => bool) approved;
}
mapping(address => Account) accounts;

Răspuns scurt: balance devine 0, dar approved rămâne neatins: delete nu poate șterge un mapping, pentru că nu știe ce chei are. Dacă utilizatorul revine, aprobările vechi sunt încă active. Soluția uzuală e un contor de versiune inclus în cheie.

delete pe un struct resetează la zero fiecare câmp de tip valoare și array-urile din el. Pentru câmpurile de tip mapping nu are ce face: un mapping nu își cunoaște cheile, deci compilatorul nu poate genera cod care să le șteargă. Documentația Solidity spune explicit că mapping-urile din struct-uri nu sunt afectate de delete. Iar delete direct pe un mapping (delete accounts[user].approved) nici nu compilează.

Consecința: după delete accounts[user] și o nouă creare a contului, accounts[user].approved[x] întoarce în continuare true pentru vechile adrese. E un bug de securitate dacă aprobările dau drepturi.

Soluția cu versiune (generație):

SOLIDITY
struct Account {
    uint256 balance;
    uint256 version;
}
mapping(address => Account) accounts;
mapping(address => mapping(uint256 => mapping(address => bool))) approved;

function isApproved(address u, address x) public view returns (bool) {
    return approved[u][accounts[u].version][x];
}

function reset(address u) internal {
    accounts[u].balance = 0;
    accounts[u].version++; // toate aprobările vechi devin invizibile
}

Datele vechi rămân fizic în storage, dar nu mai sunt citite. Alternativă: păstrezi lista cheilor (de exemplu cu EnumerableSet) și le ștergi una câte una, cu riscul de cost nelimitat.

Ce urmărește intervievatorul: Se verifică o capcană mai puțin cunoscută a lui delete. Mulți candidați presupun că delete șterge recursiv tot conținutul struct-ului.

Eroarea, în practică:Struct with a mapping cannot be constructeddelete cannot be applied to type mapping

21 Senior

Ce este transient storage și cum l-ai folosi în Solidity pentru un lacăt de reentrancy? Ce capcane are?

Răspuns scurt: Transient storage (EIP-1153, activ pe Ethereum din upgrade-ul Cancun) e un spațiu cheie-valoare care se golește automat la finalul tranzacției, cu cost de aproximativ 100 de gaz pe operație. În Solidity îl accesezi cu tstore/tload în assembly (din 0.8.24) sau cu variabile transient (din 0.8.28).

Storage-ul obișnuit e scump pentru valori care contează doar în timpul unei tranzacții: un lacăt de reentrancy scrie 1, apoi 0, și plătește costurile de SSTORE. Transient storage oferă opcode-urile TSTORE și TLOAD, cu cost fix mic, iar valorile dispar automat la finalul tranzacției.

Un lacăt cu variabilă transient (Solidity 0.8.28 sau mai nou, EVM version cancun sau mai nou):

SOLIDITY
contract Vault {
    bool transient locked;

    modifier nonReentrant() {
        if (locked) revert Reentrant();
        locked = true;
        _;
        locked = false;
    }
}

OpenZeppelin oferă ReentrancyGuardTransient începând cu versiunea 5.1.

Capcanele:

  • valoarea rămâne pe toată durata tranzacției, nu doar a apelului. Dacă uiți să o resetezi, un al doilea apel din aceeași tranzacție (de exemplu într-un multicall sau un bundle de account abstraction) găsește lacătul închis sau, invers, o valoare veche;
  • variabilele transient merg doar pentru tipuri valoare și nu pot fi constant sau immutable;
  • rețeaua țintă trebuie să suporte Cancun; unele L2-uri sau lanțuri compatibile EVM pot să nu aibă încă opcode-urile;
  • nu e un mecanism de comunicare sigur între contracte necunoscute, pentru că oricine e apelat în aceeași tranzacție poate modifica propriul transient storage.

Folosiri tipice: lacăte de reentrancy, aprobări temporare în aceeași tranzacție, flash accounting în protocoale precum Uniswap v4.

Ce urmărește intervievatorul: Se verifică dacă urmărești evoluția EVM și a limbajului. Greșeala tipică e să crezi că valoarea dispare la finalul apelului, nu al tranzacției.

Eroarea, în practică:ReentrancyGuardReentrantCall

Funcții, modifiers, constructori și events

Exersează capitolul cu exerciții reale: Curs Solidity online →
22 Junior

Ce funcții generează compilatorul pentru variabilele publice de mai jos? Cum citești tot array-ul holders dintr-o aplicație?

SOLIDITY
address[] public holders;
mapping(address => uint256) public balanceOf;
uint256 public constant FEE = 30;

Răspuns scurt: Se generează holders(uint256) returns (address), balanceOf(address) returns (uint256) și FEE() returns (uint256). Getter-ul unui array întoarce un singur element după index, nu tot array-ul; pentru listă completă scrii o funcție separată sau citești length și iterezi.

Pentru fiecare variabilă de stare public, compilatorul generează o funcție external view cu același nume. Forma ei depinde de tip:

  • tip valoare: fără parametri, întoarce valoarea (FEE());
  • mapping: un parametru pentru fiecare cheie (balanceOf(address));
  • array: un parametru index (holders(uint256)), cu revert dacă indexul e în afara limitelor;
  • struct: întoarce câmpurile ca tuple, omițând array-urile și mapping-urile din el.

De ce nu întoarce tot array-ul: costul ar fi nelimitat, iar alegerea a fost ca getter-ul să rămână constant ca preț.

Pentru listă:

SOLIDITY
function holdersCount() external view returns (uint256) {
    return holders.length;
}
function allHolders() external view returns (address[] memory) {
    return holders; // ok pentru liste mici, citite off-chain
}

Getter-urile fac parte din ABI, deci aplicația le apelează ca pe orice funcție: în ethers v6, await token.balanceOf(addr).

Două detalii care apar la interviu: în interiorul contractului folosești variabila direct (balanceOf[a]), nu getter-ul, iar this.balanceOf(a) ar fi un apel extern, mai scump. Și un getter public poate implementa o funcție dintr-o interfață, de exemplu totalSupply() din IERC20 poate fi satisfăcut de uint256 public override totalSupply.

Ce urmărește intervievatorul: Se verifică dacă știi ce face cuvântul public pe variabile. Greșeala tipică e să crezi că getter-ul unui array întoarce tot array-ul.

Eroarea, în practică:This expression is not callableIndexed expression has to be a type, mapping...

23 Junior

Scrie o funcție care întoarce simultan minimul și maximul dintr-un array și arată cum o apelezi dintr-o altă funcție, păstrând doar maximul.

Răspuns scurt: O funcție poate întoarce mai multe valori: returns (uint256 min, uint256 max). La apel le destructurezi: (, uint256 hi) = minMax(xs);, lăsând gol locul valorii pe care nu o folosești.

Solidity permite valori returnate multiple, transmise ca tuple. Le poți numi, caz în care sunt variabile locale inițializate cu zero și se întorc automat la final:

SOLIDITY
function minMax(uint256[] memory xs)
    public pure returns (uint256 min, uint256 max)
{
    if (xs.length == 0) revert Empty();
    min = xs[0];
    max = xs[0];
    for (uint256 i = 1; i < xs.length; i++) {
        if (xs[i] < min) min = xs[i];
        if (xs[i] > max) max = xs[i];
    }
}

function onlyMax(uint256[] memory xs) external pure returns (uint256) {
    (, uint256 hi) = minMax(xs);
    return hi;
}

Poți folosi și return (a, b); explicit, chiar dacă valorile sunt numite; un return explicit suprascrie ce era în variabilele numite.

Detalii utile:

  • destructurarea merge și pentru atribuiri: (a, b) = (b, a); interschimbă două variabile;
  • numele valorilor returnate apar în ABI, iar ethers v6 le expune ca proprietăți pe rezultat (res.max), pe lângă index (res[1]);
  • pentru multe valori, un struct returnat e mai lizibil decât un tuple lung și evită erorile „stack too deep”, care apar când o funcție are prea multe variabile locale și parametri.

Codul verifică explicit array-ul gol: fără verificare, xs[0] ar da revert cu Panic(0x32), un mesaj mai puțin clar pentru apelant.

Ce urmărește intervievatorul: Se verifică fluența cu sintaxa de bază și tratarea cazurilor limită. Candidații uită des cazul array-ului gol.

Eroarea, în practică:Different number of components on the left hand sideDifferent number of arguments in return statement

24 Junior

Ce poate și ce nu poate face un constructor în Solidity? De ce verificarea de mai jos e falsă când apelantul e un contract aflat în constructor?

SOLIDITY
function isContract(address a) internal view returns (bool) {
    return a.code.length > 0;
}

Răspuns scurt: Constructorul rulează o singură dată, la deploy, poate primi parametri, poate fi payable și setează immutable. În timpul constructorului, codul contractului încă nu e salvat la adresa lui, deci a.code.length e 0 și un contract aflat în construcție trece drept cont extern.

Ce face constructorul:

  • se execută o singură dată, în tranzacția de creare; codul lui nu ajunge în bytecode-ul final (runtime);
  • primește argumente, adăugate la finalul bytecode-ului de deploy;
  • poate fi payable, ca să primească ether la creare;
  • e singurul loc unde poți atribui variabile immutable;
  • dacă lipsește, compilatorul folosește unul gol.
SOLIDITY
constructor(address owner_, uint256 cap_) payable {
    if (owner_ == address(0)) revert ZeroAddress();
    owner = owner_;
    CAP = cap_; // immutable
}

Ce nu poate face: nu poate fi apelat din nou, nu poate apela propriile funcții externe prin this.f() (adresa nu are încă cod, iar Solidity verifică existența codului înainte de un apel extern de nivel înalt), iar în contractele din spatele unui proxy nu inițializează starea proxy-ului.

Despre isContract: EVM salvează codul la adresă abia după ce constructorul se termină. Un atacator care apelează contractul tău din constructor are code.length == 0. Iar verificarea mai dă rezultate greșite și pentru adrese la care se va publica un contract (de exemplu cu CREATE2). De aceea OpenZeppelin a eliminat Address.isContract în versiunea 5.

Concluzia de interviu: nu folosi „e contract sau nu” ca măsură de securitate. Dacă vrei doar conturi externe, msg.sender == tx.origin are alte probleme și blochează portofelele-contract; de obicei e mai bine să faci logica sigură pentru orice apelant.

Ce urmărește intervievatorul: Se verifică ciclul de viață al unui contract și o capcană clasică de securitate. Greșeala tipică e să crezi că code.length > 0 identifică sigur contractele.

Eroarea, în practică:Function has the same name as the contract"this" used in constructor

25 Junior

Ce valoare are x după un apel la f(), pornind de la 0? Ce se întâmplă dacă în corpul funcției pui return la început?

SOLIDITY
uint256 public x;
modifier m1() { x = x * 10 + 1; _; x = x * 10 + 2; }
modifier m2() { x = x * 10 + 3; _; x = x * 10 + 4; }

function f() external m1 m2 {
    x = x * 10 + 5;
}

Răspuns scurt: x devine 13542. Modifiers se aplică în ordinea scrisă, ca niște straturi: m1 înainte, m2 înainte, corpul, m2 după, m1 după. Un return în corp oprește doar corpul; codul de după _ din modifiers rulează în continuare.

Compilatorul transformă modifiers în cod care înconjoară corpul funcției. _ marchează locul unde intră următorul strat: pentru m1, următorul strat este m2, iar pentru m2 este corpul.

Pas cu pas:

  • m1 înainte: x = 1
  • m2 înainte: x = 13
  • corpul: x = 135
  • m2 după: x = 1354
  • m1 după: x = 13542

Ordinea contează în practică. De exemplu, onlyOwner whenNotPaused verifică întâi proprietarul, apoi pauza; dacă vrei mesajul de eroare „paused” pentru toată lumea, inversezi ordinea.

Despre return: un return explicit în corp atribuie valorile returnate și sare la finalul corpului, dar nu iese din modifiers. Codul de după _ se execută, iar valoarea întoarsă e cea din variabilele de return în momentul ieșirii. Un return într-un modifier e interzis să aibă valori și oprește execuția acelui strat, inclusiv corpul, dacă e înainte de _.

Mai rețin două lucruri:

  • _ poate apărea de mai multe ori într-un modifier, iar corpul rulează de fiecare dată; aproape întotdeauna e un bug;
  • modifiers pot primi parametri: modifier onlyRole(bytes32 r).

Codul de după _ e locul firesc pentru lucruri precum resetarea unui lacăt de reentrancy, ca în nonReentrant din OpenZeppelin.

Ce urmărește intervievatorul: Se verifică dacă înțelegi cum se compun modifiers. Mulți candidați cred că return din corp sare și peste codul de după _.

Eroarea, în practică:Modifier body does not contain '_'

26 Junior

Un coleg vrea ca un contract să citească events emise anterior ca să decidă dacă un utilizator a votat deja. De ce nu merge? Ce limitări mai au events?

Răspuns scurt: Events sunt scrise în log-urile tranzacției, în afara storage-ului, iar EVM nu oferă niciun opcode pentru a le citi; doar aplicațiile off-chain le pot interoga. Pentru logica contractului ai nevoie de o variabilă de stare, de exemplu mapping(address => bool) voted.

Un emit execută un opcode LOG0 până la LOG4, care adaugă o intrare în receipt-ul tranzacției. Intrarea are adresa contractului, până la 4 topics (primul este, de obicei, hash-ul semnăturii event-ului) și o zonă de date. Log-urile intră în calculul hash-urilor blocului, deci sunt verificabile, dar nu fac parte din starea contractului. Niciun contract, nici cel care le-a emis, nu le poate citi.

Limitări de reținut:

  • cel mult 3 parametri indexed pentru un event normal (4 pentru unul anonymous, care nu mai pune semnătura în primul topic);
  • un parametru indexed de tip dinamic (string, bytes, array, struct) nu se salvează ca valoare, ci ca keccak256 al lui; poți filtra după el, dar nu poți recupera textul original din topic;
  • events dintr-o tranzacție care dă revert dispar odată cu ea;
  • costul e mic comparativ cu storage (aproximativ 375 de gaz de bază, plus 375 pe topic și 8 pe octet de date), de aceea sunt locul potrivit pentru istoric.

Codul corect pentru vot:

SOLIDITY
mapping(uint256 => mapping(address => bool)) public voted;
event Voted(uint256 indexed proposalId, address indexed voter, bool support);

function vote(uint256 id, bool support) external {
    if (voted[id][msg.sender]) revert AlreadyVoted();
    voted[id][msg.sender] = true;
    emit Voted(id, msg.sender, support);
}

Starea servește logicii, event-ul servește interfeței și indexerelor.

Ce urmărește intervievatorul: Se verifică dacă știi unde trăiesc events și cine le poate citi. Greșeala tipică e tratarea log-urilor ca spațiu de stocare ieftin, accesibil contractului.

Eroarea, în practică:Event invocations have to be prefixed by "emit"More than 3 indexed arguments for event

27 Junior

Compilează contractul de mai jos? Ce se întâmplă la apelul f(50) și cum apelezi o funcție supraîncărcată din ethers v6?

SOLIDITY
contract Over {
    function f(uint8 x) public pure returns (uint256) { return 1; }
    function f(uint256 x) public pure returns (uint256) { return 2; }
    function g() public pure returns (uint256) { return f(50); }
}

Răspuns scurt: Declarațiile compilează, pentru că Solidity permite supraîncărcarea după tipurile parametrilor. Apelul f(50) din g nu compilează: literalul 50 se poate converti implicit atât la uint8, cât și la uint256, deci apelul e ambiguu. Din ethers v6 alegi după semnătură: contract["f(uint256)"](50).

Supraîncărcarea (overloading) înseamnă mai multe funcții cu același nume, dar cu parametri diferiți. Fiecare are alt selector, pentru că selectorul se calculează din semnătura completă (f(uint8) față de f(uint256)). Tipul returnat nu contează pentru supraîncărcare: două funcții care diferă doar prin returns nu compilează.

Compilatorul alege varianta după argumente. Dacă exact o variantă acceptă argumentele prin conversie implicită, o alege; dacă acceptă mai multe, dă eroare. Așa că:

SOLIDITY
f(uint8(50));   // varianta 1
f(uint256(50)); // varianta 2
uint256 v = 50;
f(v);           // varianta 2, uint256 nu se convertește implicit la uint8

În ethers v6, contract.f(50) dă eroare de ambiguitate, pentru că biblioteca nu știe ce variantă vrei. Specifici semnătura:

JavaScript
const r = await contract["f(uint256)"](50n);
// sau
const fn = contract.getFunction("f(uint8)");

În practică, supraîncărcarea e folosită rar și cu grijă. Exemplul clasic e safeTransferFrom din ERC-721, cu o variantă cu parametru bytes data și una fără. Pentru cod nou e de preferat nume distincte, care fac ABI-ul și integrările mai simple.

Ce urmărește intervievatorul: Se verifică regulile de rezolvare a supraîncărcării și impactul pe integrare. Candidații nu știu des că și biblioteca din front-end trebuie să primească semnătura.

Eroarea, în practică:Function with same name ... defined twiceNo matching declaration found after lookup

28 Mid

Ce sunt funcțiile libere (free functions), declarate în afara oricărui contract? Ce pot și ce nu pot face?

SOLIDITY
// Math.sol
function percent(uint256 amount, uint256 bps) pure returns (uint256) {
    return amount * bps / 10_000;
}

Răspuns scurt: Din 0.7.0 poți declara funcții la nivel de fișier. Sunt implicit internal, se copiază în contractul care le folosește și nu au acces direct la variabilele de stare, la this sau la msg.value, dar pot primi referințe storage ca parametri.

O funcție liberă se comportă ca o funcție internal dintr-o bibliotecă: codul ei se include în contractul care o apelează, apelul e un salt intern, fără CALL. Nu are vizibilitate (nu scrii internal sau public), pentru că e mereu internă.

Folosire:

SOLIDITY
import {percent} from "./Math.sol";

contract Shop {
    uint256 public constant FEE_BPS = 250;
    function fee(uint256 price) external pure returns (uint256) {
        return percent(price, FEE_BPS);
    }
}

Ce nu poate:

  • nu poate citi sau scrie variabile de stare direct, pentru că nu aparține unui contract;
  • nu are acces la this;
  • nu poate fi apelată din afara contractului și nu apare în ABI.

Ce poate: să primească un parametru storage și să-l modifice, să citească msg.sender, block.timestamp și alte variabile globale, să apeleze alte funcții libere sau contracte externe prin interfețe.

La nivel de fișier mai poți declara constant, struct, enum, error, tipuri valoare definite de utilizator (type Price is uint256;) și, din 0.8.22, event.

Comparativ cu o bibliotecă: funcțiile libere sunt mai simple de importat individual, dar nu pot fi atașate unui tip cu using ... for decât dacă le listezi explicit (using {percent} for uint256;), lucru posibil din 0.8.13.

Ce urmărește intervievatorul: Se verifică dacă cunoști elementele mai noi ale limbajului și organizarea codului. Mulți candidați nu știu că funcțiile pot exista în afara contractelor.

29 Mid

Unde e bug-ul în modifier-ul de mai jos? De ce OpenZeppelin implementează onlyOwner apelând o funcție internă?

SOLIDITY
modifier onlyOwner() {
    if (msg.sender == owner) _;
}

function withdraw() external onlyOwner returns (bool) {
    payable(owner).transfer(address(this).balance);
    return true;
}

Răspuns scurt: Pentru un apelant care nu e proprietar, corpul nu rulează, dar nici nu se dă revert: tranzacția reușește, funcția întoarce false (valoarea implicită) și nimeni nu observă. Un modifier de control trebuie să dea revert. Funcția internă reduce mărimea bytecode-ului.

Un modifier care sare peste _ fără revert face ca funcția să se termine cu succes, cu valorile returnate implicite. Apelantul neautorizat nu primește eroare, testele care verifică doar „nu s-a retras nimic” trec, iar în interfață pare că acțiunea a reușit. În funcții care întorc bool sau sume, rezultatul false sau 0 poate fi interpretat greșit de alte contracte.

Varianta corectă:

SOLIDITY
error NotOwner(address caller);

modifier onlyOwner() {
    _checkOwner();
    _;
}

function _checkOwner() internal view {
    if (msg.sender != owner) revert NotOwner(msg.sender);
}

De ce funcție internă: codul unui modifier se copiază la fiecare funcție care îl folosește. Un modifier cu logică multă, folosit în 20 de funcții, multiplică bytecode-ul și te apropie de limita de 24 KB a contractului. Mutând logica într-o funcție internă, copiezi doar un salt. Asta face și OpenZeppelin în Ownable (_checkOwner()), iar costul suplimentar la runtime e neglijabil.

Reguli bune pentru modifiers:

  • fac verificări și dau revert, nu schimbă starea (excepție: lacăte precum nonReentrant);
  • nu apelează contracte externe, ca să nu ascundă interacțiuni într-un loc unde cititorul nu se uită;
  • au nume clare, pentru că apar în semnătura funcției și sunt citite ca documentație.

Ce urmărește intervievatorul: Se verifică dacă recunoști o eroare silențioasă de control al accesului. Greșeala tipică e un modifier care „nu face nimic” în loc să dea revert.

Eroarea, în practică:OwnableUnauthorizedAccount(address)Modifier body does not contain '_'

30 Mid

Ce este un selector de funcție și cum îl obții în Solidity? Calculează selectorul pentru funcția de mai jos și explică de ce două funcții dintr-un contract nu pot avea același selector.

SOLIDITY
function transfer(address to, uint amount) external returns (bool);

Răspuns scurt: Selectorul e primii 4 octeți din keccak256 al semnăturii canonice, aici "transfer(address,uint256)", adică 0xa9059cbb. În cod îl obții cu IERC20.transfer.selector sau this.transfer.selector. EVM alege funcția după selector, deci două funcții cu același selector ar face dispatch-ul ambiguu, iar compilatorul refuză.

Când chemi o funcție, calldata începe cu 4 octeți care identifică funcția, urmați de argumentele codificate ABI. Contractul compilat compară acești octeți cu lista selectorilor săi și sare la funcția potrivită; dacă niciunul nu se potrivește, execută fallback.

Semnătura canonică folosește numele tipurilor complete, fără spații și fără numele parametrilor: uint devine uint256, un struct devine tuple-ul câmpurilor, de exemplu submit((address,uint256)).

SOLIDITY
bytes4 a = IERC20.transfer.selector;                           // 0xa9059cbb
bytes4 b = bytes4(keccak256("transfer(address,uint256)"));     // același
bytes4 c = msg.sig;                                            // selectorul apelului curent

Din linia de comandă: cast sig "transfer(address,uint256)" în Foundry.

Coliziunea: 4 octeți înseamnă 2^32 valori, deci două semnături diferite pot avea același selector (un exemplu cunoscut este collate_propagate_storage(bytes16), care are același selector ca burn(uint256)). În același contract compilatorul dă eroare. Problema reală apare între contracte diferite care împart același dispatch: un proxy și implementarea lui. Dacă proxy-ul are o funcție de administrare cu același selector ca o funcție a implementării, apelul utilizatorului ajunge la proxy. Proxy-ul transparent rezolvă asta separând apelanții: administratorul ajunge doar la funcțiile proxy-ului, restul doar la implementare.

Ce urmărește intervievatorul: Se verifică înțelegerea modului în care EVM alege funcția. Greșeala tipică e calculul cu uint în loc de uint256, care dă alt selector.

31 Mid

Care e diferența dintre f() și this.f() apelate din același contract? Ce afișează who() în fiecare caz?

SOLIDITY
contract C {
    function whoCalled() public view returns (address) { return msg.sender; }
    function who() external view returns (address internalCall, address externalCall) {
        internalCall = whoCalled();
        externalCall = this.whoCalled();
    }
}

Răspuns scurt: whoCalled() e un apel intern, un simplu salt: msg.sender rămâne cel care a apelat who. this.whoCalled() e un apel extern, un CALL (aici STATICCALL) către propria adresă: msg.sender devine adresa contractului C. Apelul extern e și mai scump.

Un apel intern se compilează ca JUMP în același context de execuție. Argumentele de tip referință din memory se transmit prin referință, nu se recodifică, iar msg.sender, msg.value și starea rămân ale apelului inițial.

Un apel prin this iese din contract și intră înapoi ca un mesaj nou:

  • argumentele se codifică ABI și se decodifică;
  • msg.sender devine address(this);
  • msg.value e 0, dacă nu trimiți explicit {value: ...};
  • se plătește costul unui apel extern și al codificării;
  • funcția trebuie să fie public sau external.

Când e necesar this:

  • pentru a apela o funcție external din același contract, pentru că una external nu poate fi chemată intern;
  • pentru a folosi try/catch pe propriul cod, deoarece try merge doar pe apeluri externe;
  • în anumite tipare de multicall.

Capcanele:

  • în constructor, this.f() eșuează, pentru că la adresă încă nu există cod;
  • dacă whoCalled ar fi protejată de onlyOwner, apelul prin this ar eșua, pentru că apelantul ar fi contractul însuși;
  • dacă f ar schimba starea și ai un nonReentrant pe ambele, apelul prin this ar fi blocat ca reentrancy.

Regula practică: folosește apeluri interne și marchează funcțiile public dacă ai nevoie să le chemi și din interior; păstrează this. pentru cazurile de mai sus.

Ce urmărește intervievatorul: Se verifică înțelegerea diferenței dintre apel intern și mesaj extern. Mulți candidați nu știu că this.f() schimbă msg.sender.

Erori, revert și overflow

32 Junior

Contractul A apelează contractul B, iar B dă revert. Ce se întâmplă cu modificările făcute deja de A în aceeași tranzacție, în cele două variante de mai jos?

SOLIDITY
function viaInterface() external {
    counter++;
    IB(b).doWork();
}
function viaCall() external {
    counter++;
    (bool ok, ) = b.call(abi.encodeCall(IB.doWork, ()));
}

Răspuns scurt: În viaInterface, revert-ul din B se propagă în A, deci se anulează toată tranzacția, inclusiv counter++. În viaCall, se anulează doar modificările lui B, call întoarce ok = false, iar counter++ rămâne, dacă A nu dă revert singur.

Fiecare apel extern rulează într-un sub-context. Dacă sub-contextul dă revert, EVM anulează tot ce a modificat el și întoarce controlul apelantului cu un indicator de eșec și cu datele de revert. Apelantul decide ce face mai departe.

Apelul de nivel înalt (IB(b).doWork()): compilatorul generează cod care verifică rezultatul și, la eșec, face la rândul lui revert cu aceleași date. Eroarea „urcă” până la tranzacție, iar toate modificările dispar. E comportamentul dorit aproape mereu.

Apelul de nivel jos (b.call(...)): nu se face nicio verificare automată. Doar B e anulat. Dacă A nu verifică ok, codul continuă ca și cum totul a reușit. Aici funcția incrementează contorul fără ca munca din B să fi avut loc, adică o stare inconsistentă.

SOLIDITY
(bool ok, bytes memory ret) = b.call(abi.encodeCall(IB.doWork, ()));
if (!ok) revert WorkFailed(ret);

try/catch se comportă similar cu call: dacă B dă revert, se anulează doar B și se execută ramura catch, unde decizi.

Gazul consumat de B până la revert nu se recuperează, iar dacă tranzacția dă revert, nici gazul lui A, chiar dacă starea se anulează complet.

Regula: alegi intenționat dacă un eșec al unui apel extern trebuie să oprească totul sau să fie tolerat, și verifici întotdeauna rezultatul apelurilor de nivel jos.

Ce urmărește intervievatorul: Se verifică înțelegerea propagării erorilor între contracte. Greșeala tipică e să crezi că un revert în B anulează automat și A și când folosești call.

Eroarea, în practică:Return value of low-level calls not used

33 Junior

Ce diferență vede front-end-ul între cele trei variante? Care e cea recomandată în Solidity 0.8.26 sau mai nou?

SOLIDITY
require(msg.sender == owner, "Only owner can call");
if (msg.sender != owner) revert NotOwner();
require(msg.sender == owner, NotOwner());

Răspuns scurt: Prima produce Error(string), cu textul în bytecode și în datele de revert. Celelalte produc custom error-ul NotOwner(), doar 4 octeți de selector, mai ieftin. Forma require(cond, CustomError()) merge din 0.8.26 și e cea mai lizibilă.

Datele de revert sunt octeți codificați ABI, la fel ca un apel de funcție:

  • require(cond, "text") produce selectorul 0x08c379a0 (Error(string)) urmat de string. Textul ocupă bytecode, iar fiecare caracter în plus crește costul de deploy;
  • revert NotOwner() produce doar cei 4 octeți ai selectorului NotOwner(), plus eventualii parametri codificați.

Front-end-ul trebuie să cunoască ABI-ul contractului (care include și declarațiile error) ca să traducă selectorul în nume. ethers v6 face asta automat când are ABI-ul complet; altfel vezi doar octeți.

Istoric: custom errors au apărut în 0.8.4 și puteau fi folosite doar cu if (...) revert X();. Din 0.8.26, require acceptă direct o eroare custom, dar doar cu pipeline-ul via-IR; din 0.8.27 merge și cu pipeline-ul clasic. Pe versiuni mai vechi a treia linie nu compilează.

Recomandarea pentru cod nou:

SOLIDITY
error NotOwner(address caller);

function setFee(uint256 f) external {
    require(msg.sender == owner, NotOwner(msg.sender));
    fee = f;
}

Erorile custom pot avea parametri, sunt documentate în ABI și se pot testa precis (vm.expectRevert(abi.encodeWithSelector(NotOwner.selector, alice))). require simplu, fără mesaj, dă revert fără date, ceea ce face depanarea foarte grea.

Ce urmărește intervievatorul: Se verifică dacă știi cum arată erorile la nivel de octeți și evoluția sintaxei. Mulți candidați nu știu din ce versiune merge require cu custom error.

Eroarea, în practică:reverted with reason string '...'Transaction reverted without a reason string

34 Junior

Declară o eroare custom pentru „sold insuficient” care spune cât are utilizatorul și cât a cerut. Cum o decodezi în ethers v6 și cum o testezi în Foundry?

Răspuns scurt: Declari error InsufficientBalance(uint256 available, uint256 required); și faci revert InsufficientBalance(bal, amount);. În ethers v6 citești err.revert.name și err.revert.args sau folosești contract.interface.parseError(data). În Foundry testezi cu vm.expectRevert(abi.encodeWithSelector(...)).

Declarația poate sta în contract, într-o interfață sau la nivel de fișier, ca să fie refolosită:

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;
    (bool ok, ) = msg.sender.call{value: amount}("");
    if (!ok) revert TransferFailed();
}

Datele de revert: 4 octeți de selector (bytes4(keccak256("InsufficientBalance(uint256,uint256)"))), apoi cele două valori codificate ABI.

În ethers v6, dacă instanța de Contract are ABI-ul cu declarația erorii:

JavaScript
try {
  await vault.withdraw(10n);
} catch (err) {
  if (err.revert?.name === "InsufficientBalance") {
    const [available, required] = err.revert.args;
  }
}

Dacă ai doar octeții (de exemplu dintr-un eth_call sau un log), folosești vault.interface.parseError(data).

În Foundry:

SOLIDITY
vm.expectRevert(
    abi.encodeWithSelector(Vault.InsufficientBalance.selector, 0, 10)
);
vault.withdraw(10);

Pentru o eroare fără parametri ajunge vm.expectRevert(Vault.ZeroAmount.selector). Parametrii fac mesajul util fără să consume bytecode pentru text, iar testul verifică exact valorile, nu doar faptul că s-a dat revert.

Ce urmărește intervievatorul: Se verifică fluxul complet al unei erori, de la contract la interfață și teste. Greșeala tipică e să testezi doar că funcția dă revert, fără motiv.

Eroarea, în practică:reverted with custom error '...'ERC20InsufficientBalance

35 Junior

Ce eroare primești în fiecare caz și cum o recunoști după datele de revert?

SOLIDITY
uint256[] arr;
function a() external view returns (uint256) { return arr[5]; }
function b(uint256 x) external pure returns (uint256) { return 10 / x; } // x = 0
function c() external { arr.pop(); }                                   // arr gol
function d(uint8 x) external pure returns (uint8) { return x + 250; }  // x = 10
function e() external pure { assert(false); }

Răspuns scurt: Toate dau Panic(uint256), cu selectorul 0x4e487b71 și un cod: a 0x32 (index în afara limitelor), b 0x12 (împărțire la zero), c 0x31 (pop pe array gol), d 0x11 (overflow), e 0x01 (assert eșuat).

Solidity 0.8 deosebește două tipuri de erori. Error(string) și custom errors sunt erori „așteptate”, aruncate de cod (require, revert), de obicei din cauza inputului. Panic(uint256) semnalează condiții care nu ar trebui să apară niciodată într-un cod corect, generate automat de compilator.

Codurile cele mai întâlnite:

  • 0x01: assert eșuat;
  • 0x11: overflow sau underflow aritmetic în afara unui bloc unchecked;
  • 0x12: împărțire sau modulo la zero;
  • 0x21: conversie invalidă către enum;
  • 0x31: pop() pe array gol;
  • 0x32: acces la index în afara limitelor;
  • 0x41: alocare prea mare de memorie;
  • 0x51: apel al unei variabile de tip funcție internă neinițializate.

Din 0.8.0, și assert folosește opcode-ul REVERT, nu INVALID, deci restul gazului se returnează. Înainte de 0.8, un assert eșuat consuma tot gazul.

În Foundry testezi panica precis:

SOLIDITY
import {stdError} from "forge-std/StdError.sol";
vm.expectRevert(stdError.arithmeticError); // 0x11
c.d(10);

Un auditor tratează orice Panic atins prin input extern ca semn de bug: fie lipsește o validare cu eroare clară, fie un invariant e încălcat. Dacă un utilizator poate declanșa Panic(0x01), assert-ul respectiv a fost folosit greșit în loc de require.

Ce urmărește intervievatorul: Se verifică dacă știi să citești o eroare de tip panic și ce înseamnă. Mulți candidați nu știu că există coduri distincte pentru fiecare caz.

Eroarea, în practică:panic code 0x11 (underflow / overflow)panic code 0x12 (division by zero)

36 Mid

Solidity 0.8 verifică overflow-ul. Unde poate totuși să apară wrap-around fără revert? Ce întoarce funcția de mai jos?

SOLIDITY
function f() external pure returns (uint8 a, uint8 b, uint256 c) {
    uint8 x = 200;
    unchecked { a = x + 100; }
    b = x << 1;
    c = uint256(int256(-5));
}

Răspuns scurt: a este 44 (wrap în unchecked), b este 144 (deplasările nu sunt verificate), iar c este 2^256 - 5 (conversia reinterpretează biții). Wrap-around mai apare în inline assembly și la conversii explicite către tipuri mai mici.

Verificarea automată acoperă +, -, *, /, **, ++, -- și negarea unară pe întregi cu semn. Sunt câteva excepții pe care trebuie să le cunoști:

  • blocurile unchecked { ... }, unde aritmetica revine la comportamentul modular: 200 + 100 = 300, modulo 256 dă 44;
  • deplasările << și >>: documentația precizează că nu se face verificare de overflow pentru shift. 200 << 1 este 400, trunchiat la uint8 dă 144;
  • conversiile explicite, care taie sau reinterpretează biții;
  • inline assembly (Yul), unde add, mul, sub sunt mereu modulare pe 256 de biți.

unchecked e folosit intenționat când știi că operația nu poate depăși (de exemplu un contor de buclă limitat de length) sau când vrei explicit aritmetică modulară (hash-uri, contoare de tip ring buffer). Codul din unchecked trebuie însoțit de un comentariu care explică de ce e sigur.

Un exemplu periculos:

SOLIDITY
function withdraw(uint256 amount) external {
    unchecked { balances[msg.sender] -= amount; } // underflow → sold uriaș
    payable(msg.sender).transfer(amount);
}

Optimizarea de gaz a transformat o funcție sigură într-una exploatabilă.

Atenție: împărțirea la zero dă revert și în unchecked. Diferența de gaz pentru o singură operație verificată e de câteva zeci de unități, deci unchecked merită doar în bucle sau în căi foarte frecvente.

Ce urmărește intervievatorul: Se verifică dacă știi limitele protecției din 0.8. Mulți candidați cred că după 0.8 nu mai există niciun wrap-around.

Eroarea, în practică:panic code 0x11 (underflow / overflow)

37 Mid

Un contract de tip router face un apel de nivel jos și, la eșec, vrea să transmită mai departe exact eroarea primită (de exemplu InsufficientBalance(5, 10)), nu un mesaj generic. Cum scrii asta?

Răspuns scurt: Iei datele de revert din call și faci revert cu ele în assembly: assembly { revert(add(ret, 32), mload(ret)) }. Așa apelantul primește aceeași eroare, cu același selector și aceiași parametri. Address.functionCall din OpenZeppelin face exact asta.

Un call care eșuează întoarce false și datele de revert ale apelului, ca bytes memory. Dacă faci revert CallFailed(), informația utilă se pierde și utilizatorul vede doar „CallFailed”. Pentru a o păstra, o retransmiți neschimbată:

SOLIDITY
function forward(address target, bytes calldata data) external returns (bytes memory) {
    (bool ok, bytes memory ret) = target.call(data);
    if (!ok) {
        if (ret.length == 0) revert CallFailed();   // revert fără date sau fără gaz
        assembly {
            revert(add(ret, 32), mload(ret))
        }
    }
    return ret;
}

Explicația assembly-ului: în memory, un bytes începe cu 32 de octeți care conțin lungimea, urmați de date. mload(ret) citește lungimea, add(ret, 32) dă adresa primului octet de date, iar revert(offset, size) încheie execuția cu acei octeți ca date de revert.

Variante:

  • Address.functionCall(target, data) din OpenZeppelin face aceeași propagare și dă o eroare proprie dacă nu există date;
  • dacă vrei să adaugi context, poți împacheta: revert CallFailedWith(target, ret), cu prețul că apelantul trebuie să decodeze două niveluri.

Atenție la două lucruri: nu decodezi orbește ret cu abi.decode(ret, (string)), pentru că nu toate erorile sunt Error(string) și decodarea poate da ea însăși revert; și te gândești dacă apelantul are încredere în target, pentru că datele de revert pot fi mari și pot consuma gaz la copiere.

Ce urmărește intervievatorul: Se verifică stăpânirea apelurilor de nivel jos și a formatului memoriei. Greșeala tipică e decodarea forțată a erorii ca string.

38 Senior

Ce erori prinde și ce erori nu prinde try/catch de mai jos?

SOLIDITY
try oracle.getPrice(asset) returns (uint256 p) {
    price = p;
} catch Error(string memory reason) {
    emit Failed(reason);
} catch Panic(uint256 code) {
    emit PanicCode(code);
} catch (bytes memory data) {
    emit Raw(data);
}

Răspuns scurt: Prinde revert-urile din apelul extern: Error(string), Panic, custom errors, lipsa de gaz a callee. Nu prinde erorile din contractul apelant: adresă fără cod, decodarea eșuată a rezultatului, gaz insuficient după apel, revert în catch.

try funcționează doar pe apeluri externe și pe crearea de contracte cu new. EVM întoarce succes sau eșec pentru sub-apel, iar Solidity alege ramura:

  • catch Error(string): revert cu mesaj text;
  • catch Panic(uint256): assert, overflow, împărțire la zero în callee;
  • catch (bytes memory): orice altceva, inclusiv custom errors și revert fără date;
  • un catch { } gol prinde tot ce n-au prins celelalte, fără date.

Ce nu e prins, pentru că se întâmplă în contractul tău, nu în callee:

  • dacă oracle nu are cod, verificarea de existență a codului făcută de Solidity dă revert înainte de apel. Din 0.8.10 verificarea e omisă când funcția întoarce date, iar eșecul apare la decodare, tot în apelant;
  • dacă callee întoarce date care nu pot fi decodate ca uint256 (de exemplu mai puțini octeți), decodarea dă revert în apelant;
  • dacă apelul consumă aproape tot gazul, apelantul rămâne cu 1/64 (regula EIP-150) și poate rămâne fără gaz după catch;
  • un revert în corpul try sau în catch se propagă normal.

Consecința de securitate: un oracol rău-intenționat poate întoarce date malformate și bloca apelantul, deși acesta credea că a tratat eșecul. Codul robust validează lungimea datelor folosind un staticcall de nivel jos și decodează manual:

SOLIDITY
(bool ok, bytes memory ret) = address(oracle).staticcall(
    abi.encodeCall(IOracle.getPrice, (asset))
);
if (ok && ret.length == 32) price = abi.decode(ret, (uint256));

Ce urmărește intervievatorul: Se verifică înțelegerea fină a granițelor lui try/catch. Mulți candidați cred că try prinde orice eroare legată de apel.

Eroarea, în practică:function call to a non-contract account

Ether, apeluri externe și ABI

39 Junior

De ce nu compilează funcția de mai jos? Ce se întâmplă dacă cineva trimite ether către o funcție care nu e payable?

SOLIDITY
mapping(address => uint256) public deposits;

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

Răspuns scurt: Compilatorul permite folosirea msg.value doar în funcții payable (sau interne apelate din ele), deci aici dă eroare. O funcție fără payable verifică automat la intrare că msg.value == 0 și dă revert dacă s-a trimis ether.

Marcajul payable are două efecte. La compilare, permite citirea msg.value în funcțiile publice și externe. La runtime, elimină verificarea pe care compilatorul o pune la începutul fiecărei funcții non-payable, care respinge orice apel cu ether atașat. Datorită acestei verificări, ether-ul nu ajunge din greșeală într-o funcție care nu știe să-l contabilizeze.

Varianta corectă:

SOLIDITY
event Deposited(address indexed from, uint256 amount);

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

Detalii care apar la interviu:

  • payable e și o micro-optimizare: lipsa verificării economisește câteva zeci de gaz, motiv pentru care unele echipe marchează funcțiile de administrare payable; e o alegere discutabilă, pentru că ether-ul trimis din greșeală rămâne blocat;
  • funcțiile view și pure nu pot fi payable;
  • o funcție internă poate citi msg.value dacă nu e view/pure; valoarea e a apelului extern curent, deci poate fi contabilizată de mai multe ori dacă o refolosești din greșeală, de exemplu într-o buclă;
  • trimiterea de ether la crearea contractului cere constructor payable;
  • ether-ul poate ajunge totuși în contract și fără payable, prin recompensa blocului sau prin selfdestruct al altui contract.

În teste, Foundry trimite valoare cu c.deposit{value: 1 ether}(), după ce dai ether contului cu vm.deal.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului payable. Greșeala tipică e să crezi că un contract fără funcții payable nu poate avea niciodată sold.

Eroarea, în practică:"msg.value" can only be used in payable functionsnon-payable function was called with value

40 Junior

Ce funcție se execută în fiecare dintre cele patru apeluri către contractul de mai jos?

SOLIDITY
contract Sink {
    event R(); event F();
    receive() external payable { emit R(); }
    fallback() external { emit F(); }
}

1. 1 ether, fără date 2. 0 ether, cu date 0x12345678 3. 1 ether, cu date 0x12345678 4. 0 ether, fără date

Răspuns scurt: 1: receive. 2: fallback. 3: revert, pentru că datele nu corespund niciunei funcții, deci ajunge la fallback, care nu e payable. 4: receive, pentru că receive se alege după calldata goală, indiferent de valoare.

Regula de dispatch, aplicată de codul generat de compilator:

  • dacă primii 4 octeți din calldata corespund unei funcții, se execută funcția;
  • altfel, dacă calldata e goală și există receive, se execută receive;
  • altfel, se execută fallback, dacă există;
  • dacă nu există nici fallback, apelul dă revert.

Apoi se aplică verificarea payable: dacă funcția aleasă nu e payable și s-a trimis ether, revert.

Pentru cazurile din întrebare:

  • cazul 3 e capcana: mulți se așteaptă ca receive să preia ether-ul, dar receive nu e luat în calcul când există date. fallback nu e payable, deci revert;
  • cazul 4 surprinde și el: receive rulează chiar fără ether, pentru că decizia se ia doar după calldata.

Alte reguli:

  • receive trebuie să fie external payable, fără parametri și fără valori returnate;
  • fallback poate avea forma fallback(bytes calldata input) external [payable] returns (bytes memory output), folosită de proxy-uri;
  • dacă lipsește receive, dar fallback e payable, fallback primește și transferurile fără date;
  • trimiterile cu transfer și send dau doar 2300 de gaz, deci receive nu poate scrie în storage în acel caz; un emit simplu încape.

În cod real păstrezi aceste funcții minime și le testezi explicit, pentru că ele sunt punctul de intrare pentru ether neașteptat.

Ce urmărește intervievatorul: Se verifică dacă știi exact regulile de dispatch, nu doar rolul celor două funcții. Cazurile 3 și 4 separă candidații care au testat de cei care au citit.

Eroarea, în practică:non-payable function was called with valueExpected a state variable declaration (fallback)

41 Junior

Jocul de mai jos se termină când soldul contractului ajunge exact la 5 ether. Ce e greșit în logică?

SOLIDITY
function play() external payable {
    require(msg.value == 1 ether, "1 ether");
    uint256 before = address(this).balance;
    if (before + msg.value == 5 ether) {
        winner = msg.sender;
    }
}

Răspuns scurt: În interiorul unei funcții payable, address(this).balance include deja msg.value, deci ether-ul se adună de două ori și câștigătorul e ales la al patrulea joc, nu la al cincilea. În plus, egalitatea exactă poate fi ruptă de ether trimis forțat.

Transferul de valoare are loc înainte ca primul opcode al contractului să ruleze. Când play() începe, soldul contractului e deja mărit cu msg.value. Formula corectă pentru soldul de dinainte este address(this).balance - msg.value.

Problema a doua e verificarea de egalitate pe soldul real. Ether-ul poate ajunge în contract fără să treacă prin cod: ca destinatar al recompensei unui bloc sau prin selfdestruct dintr-un alt contract (după EIP-6780, selfdestruct nu mai șterge codul în afara tranzacției de creare, dar tot trimite soldul). Cineva care trimite 0,5 ether forțat face ca soldul să nu mai fie niciodată exact 5 ether, iar jocul se blochează pentru totdeauna.

Varianta robustă folosește contabilitate internă:

SOLIDITY
uint256 public pot;

function play() external payable {
    if (msg.value != 1 ether) revert WrongAmount();
    if (winner != address(0)) revert GameOver();
    pot += msg.value;
    if (pot >= 5 ether) {
        winner = msg.sender;
    }
}

Reguli generale:

  • logica depinde de variabile proprii (pot, totalDeposits), nu de address(this).balance;
  • folosești >= în loc de == pentru praguri;
  • surplusul neașteptat poate fi recuperat printr-o funcție de administrare, separat de logica utilizatorilor.

Același tip de bug apare cu tokenii: token.balanceOf(address(this)) poate fi umflat de oricine printr-un transfer direct.

Ce urmărește intervievatorul: Se verifică două lucruri: momentul în care se actualizează soldul și invarianți care pot fi rupți din exterior. Prima parte o ratează majoritatea candidaților.

Eroarea, în practică:this.balance: use address(this).balance

42 Mid

Rescrie funcția de mai jos după modelul pull over push și explică ce problemă rezolvi.

SOLIDITY
address[] public investors;
mapping(address => uint256) public invested;

function refundAll() external onlyOwner {
    for (uint256 i; i < investors.length; i++) {
        address inv = investors[i];
        payable(inv).transfer(invested[inv]);
        invested[inv] = 0;
    }
}

Răspuns scurt: Funcția face push: trimite tuturor într-o buclă. Un singur destinatar care refuză plata blochează toată funcția, iar o listă lungă depășește gazul blocului. Cu pull, contractul doar marchează sumele datorate, iar fiecare investitor își retrage singur banii.

Problemele variantei push:

  • dacă un investitor e un contract cu receive care dă revert sau consumă mult gaz, transfer eșuează și tot refundAll dă revert. Nimeni nu mai primește nimic;
  • numărul de iterații crește cu lista; la un moment dat tranzacția nu mai încape într-un bloc;
  • starea se actualizează după transfer, deci varianta cu call ar fi și vulnerabilă la reentrancy.

Varianta pull:

SOLIDITY
bool public refundsOpen;

function openRefunds() external onlyOwner {
    refundsOpen = true;
}

function claimRefund() external {
    if (!refundsOpen) revert RefundsClosed();
    uint256 amount = invested[msg.sender];
    if (amount == 0) revert NothingToClaim();
    invested[msg.sender] = 0;                           // efect înainte de interacțiune
    (bool ok, ) = msg.sender.call{value: amount}("");
    if (!ok) revert TransferFailed();
    emit Refunded(msg.sender, amount);
}

Fiecare investitor plătește gazul propriei retrageri, un destinatar problematic se blochează doar pe sine, iar costul fiecărei tranzacții e constant.

Dezavantajul: utilizatorii trebuie să facă o acțiune, iar unii nu o vor face. Interfața trebuie să afișeze clar suma disponibilă, iar contractul poate emite un event când deschide retragerile.

Când e acceptabil push: un număr mic și fix de destinatari de încredere, de exemplu împărțirea comisioanelor între doi parteneri, cu fallback la pull pentru plățile eșuate.

Ce urmărește intervievatorul: Se verifică dacă poți refactoriza un tipar fragil și explica de ce. Greșeala tipică e să înlocuiești doar transfer cu call, păstrând bucla.

43 Mid

Ce diferențe sunt între cele trei moduri de a construi calldata pentru același apel? Care e cel mai sigur?

SOLIDITY
bytes memory a = abi.encodeWithSignature("transfer(address,uint)", to, amount);
bytes memory b = abi.encodeWithSelector(IERC20.transfer.selector, to, amount);
bytes memory c = abi.encodeCall(IERC20.transfer, (to, amount));

Răspuns scurt: a are un bug: semnătura cu uint în loc de uint256 dă alt selector, iar compilatorul nu observă. b are selectorul corect, dar argumentele nu sunt verificate la tip. c (din 0.8.11) verifică și funcția, și tipurile argumentelor, deci e cel mai sigur.

Toate trei produc selector de 4 octeți plus argumente codificate ABI. Diferența e cât verifică compilatorul.

abi.encodeWithSignature(string, ...): calculează keccak256 pe textul dat. Orice greșeală de scriere (spații, uint în loc de uint256, nume greșit) produce un selector valid, dar al altei funcții. Apelul ajunge la fallback sau dă revert, iar bug-ul apare doar la runtime.

abi.encodeWithSelector(bytes4, ...): selectorul vine din declarația funcției, deci nu poate fi scris greșit. Argumentele însă sunt codificate după tipurile lor reale: dacă treci (amount, to) în ordine inversă sau un uint128, codificarea iese, dar nu corespunde funcției.

abi.encodeCall(function, (args)): compilatorul verifică faptul că tuple-ul de argumente se potrivește cu parametrii funcției, cu aceleași reguli de conversie ca la un apel normal. Greșelile apar la compilare.

Pereche utilă, decodarea rezultatului:

SOLIDITY
(bool ok, bytes memory ret) = token.call(abi.encodeCall(IERC20.transfer, (to, amount)));
bool success = ok && (ret.length == 0 || abi.decode(ret, (bool)));
if (!success) revert TransferFailed();

Verificarea ret.length == 0 acceptă tokenii mai vechi care nu întorc nimic. Asta face, în esență, SafeERC20.

abi.encodeWithSignature rămâne util doar când nu ai interfața la compilare, de exemplu într-un script generic. În cod de producție, encodeCall e alegerea implicită.

Ce urmărește intervievatorul: Se verifică atenția la detalii în apelurile de nivel jos. Bug-ul cu uint din semnătură apare surprinzător de des în cod real.

44 Mid

Ce este staticcall și când îl folosește compilatorul automat? Ce se întâmplă dacă funcția apelată încearcă să scrie în storage?

Răspuns scurt: staticcall e un apel extern în care orice modificare de stare (SSTORE, LOG, creare de contract, trimitere de ether) eșuează. Compilatorul îl folosește automat pentru funcțiile declarate view sau pure. O scriere în storage din callee face apelul să eșueze.

Opcode-ul STATICCALL a fost introdus în upgrade-ul Byzantium (EIP-214). Execuția din sub-apel și din orice apel făcut mai departe de el e în mod „doar citire”; încercarea de a modifica starea oprește execuția cu eșec.

Din Solidity 0.5.0, un apel de nivel înalt către o funcție declarată view sau pure se compilează ca STATICCALL. Asta are o consecință interesantă:

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

contract Bad {
    uint256 public calls;
    function price() external returns (uint256) { calls++; return 100; }
}

// în alt contract
uint256 p = IPrice(address(bad)).price(); // revert: Bad scrie în storage

Interfața spune view, implementarea nu respectă, iar apelul eșuează. Compilatorul nu poate verifica implementarea unui contract extern, dar garantează măcar că interfața ta nu va permite modificări de stare.

Folosire explicită, la nivel jos:

SOLIDITY
(bool ok, bytes memory ret) = token.staticcall(
    abi.encodeCall(IERC20.balanceOf, (user))
);

E alegerea potrivită când citești date de la un contract în care nu ai încredere: îi garantezi că nu poate modifica nimic în timpul apelului, inclusiv să reintre în contractul tău cu o funcție care scrie.

Limitare: staticcall nu protejează de reentrancy de tip read-only, în care contractul extern citește starea ta într-un moment inconsistent. Pentru asta ai nevoie de ordinea corectă a operațiilor.

Ce urmărește intervievatorul: Se verifică dacă știi ce garantează view la nivel de EVM. Mulți candidați cred că view e doar o adnotare fără efect la runtime.

45 Mid

Scrie un contract factory care creează portofele simple, fiecare cu proprietar, și poate primi ether la creare. Cum faci adresa previzibilă și cum eviți ca altcineva să ocupe adresa unui utilizator?

Răspuns scurt: Folosești new Wallet{value: msg.value, salt: s}(owner), care face CREATE2, deci adresa depinde doar de factory, salt și bytecode. Incluzi msg.sender în salt, ca nimeni altcineva să nu poată crea portofelul la adresa care îi corespunde utilizatorului.

Varianta de bază:

SOLIDITY
contract Wallet {
    address public immutable owner;
    constructor(address owner_) payable { owner = owner_; }
    receive() external payable {}
}

contract WalletFactory {
    event Created(address indexed owner, address wallet);

    function create(bytes32 userSalt) external payable returns (address w) {
        bytes32 salt = keccak256(abi.encode(msg.sender, userSalt));
        w = address(new Wallet{value: msg.value, salt: salt}(msg.sender));
        emit Created(msg.sender, w);
    }

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

Puncte de discutat:

  • fără salt, new folosește CREATE și adresa depinde de nonce-ul factory-ului, deci nu poate fi calculată sigur înainte;
  • creationCode trebuie concatenat cu argumentele constructorului, altfel predicția e greșită;
  • același salt folosit a doua oară dă revert, pentru că adresa e deja ocupată;
  • fără msg.sender în salt, un atacator care vede tranzacția în mempool poate crea primul portofelul cu acel salt și un alt proprietar (dacă proprietarul ar fi parametru liber), ocupând adresa pe care utilizatorul o comunicase deja altora;
  • adresa previzibilă permite primirea de fonduri înainte de deploy.

Pentru multe instanțe identice, clonele minimale (EIP-1167) reduc mult costul de creare.

Ce urmărește intervievatorul: Se verifică dacă poți scrie un factory complet și dacă te gândești la front-running pe adrese. Greșeala tipică e un salt controlat integral de oricine.

Eroarea, în practică:Unknown call option. Valid options: salt, value, gas

Moștenire, biblioteci și contracte upgradeable

Exersează capitolul cu exerciții reale: Curs Solidity online →
46 Junior

Cum transmiți argumente constructorului unui contract părinte? Ce variantă alegi în fiecare situație?

SOLIDITY
contract Base {
    uint256 public fee;
    constructor(uint256 fee_) { fee = fee_; }
}

Răspuns scurt: Fie direct în lista de moștenire, când valoarea e fixă: contract A is Base(30) {}, fie în constructorul copilului, când depinde de parametri: constructor(uint256 f) Base(f * 2) {}. Dacă nu dai argumente, contractul copil trebuie marcat abstract.

Cele două sintaxe:

SOLIDITY
contract FixedFee is Base(30) {}

contract CustomFee is Base {
    constructor(uint256 f) Base(f * 2) {}
}

Prima e mai scurtă și se folosește când valoarea e constantă. A doua permite calcule sau parametri primiți la deploy. Nu poți folosi ambele pentru aceeași bază; compilatorul refuză.

Ordinea execuției: constructorii rulează în ordinea liniarizării, de la baza cea mai generală la contractul cel mai derivat, indiferent de ordinea în care scrii modifiers ai constructorului. Argumentele sunt evaluate însă în ordinea în care apar.

Exemplu realist cu OpenZeppelin 5:

SOLIDITY
contract MyToken is ERC20, Ownable {
    constructor(address initialOwner)
        ERC20("My Token", "MTK")
        Ownable(initialOwner)
    {
        _mint(initialOwner, 1_000_000e18);
    }
}

În versiunea 5, Ownable cere explicit proprietarul inițial. Codul copiat din tutoriale pentru versiunea 4 (Ownable() fără argumente) nu mai compilează, eroare frecventă la interviurile cu temă.

Dacă nu dai argumentele unei baze care le cere, contractul nu poate fi publicat, deci trebuie declarat abstract. E util pentru contracte intermediare, unde contractul final decide valorile. Din 0.7.0, constructorii nu mai au vizibilitate (public/internal); un contract care nu trebuie publicat direct e marcat abstract.

Ce urmărește intervievatorul: Se verifică sintaxa de bază a moștenirii și familiaritatea cu OpenZeppelin 5. Mulți candidați scriu încă Ownable() fără argument.

Eroarea, în practică:No arguments passed to the base constructorBase constructor arguments given twice

47 Junior

Ce compilează și ce nu în contractul copil? Explică diferența dintre private și internal la moștenire.

SOLIDITY
contract Parent {
    uint256 private secret = 1;
    uint256 internal shared = 2;
    function _helper() private pure returns (uint256) { return 3; }
}

contract Child is Parent {
    function a() external view returns (uint256) { return secret; }
    function b() external view returns (uint256) { return shared; }
    function c() external pure returns (uint256) { return _helper(); }
    uint256 shared = 5;
}

Răspuns scurt: b compilează. a și c nu, pentru că membrii private sunt vizibili doar în contractul care îi declară, nu și în cei derivați. Redeclararea shared nu compilează nici ea: din 0.6.0, shadowing-ul variabilelor de stare e interzis.

Vizibilitatea în moștenire:

  • private: doar în contractul care declară; copiii nu au acces, deși variabila există în storage-ul lor;
  • internal: în contract și în toți cei derivați; e implicit pentru variabilele de stare;
  • public: ca internal, plus getter extern.

private nu ascunde datele: oricine le citește din storage cu eth_getStorageAt. Rolul lui e de încapsulare a codului, nu de confidențialitate. Biblioteci precum OpenZeppelin 5 folosesc intens private pentru starea internă, ca un contract derivat să nu poată modifica direct soldurile, ci doar prin funcții internal care păstrează invarianții (de exemplu _update, care emite și Transfer).

Despre shadowing: în versiunile vechi, declararea unei variabile cu același nume în copil crea o a doua variabilă, iar codul părintelui o folosea pe a lui. Rezultatul era confuz și a produs bug-uri. Din 0.6.0, compilatorul dă eroare. Variabilele locale și parametrii care umbresc variabile de stare sunt încă permise, dar dau warning.

Corectarea exemplului:

SOLIDITY
contract Parent {
    uint256 private secret = 1;
    uint256 internal shared = 2;
    function _secret() internal view returns (uint256) { return secret; }
}

contract Child is Parent {
    function a() external view returns (uint256) { return _secret(); }
    constructor() { shared = 5; }
}

Expui intenționat ce au voie copiii să folosească, prin funcții internal.

Ce urmărește intervievatorul: Se verifică regulile de vizibilitate la moștenire și înțelegerea faptului că private nu înseamnă secret. Shadowing-ul interzis surprinde candidații care au învățat din materiale vechi.

48 Junior

Ce poate conține o interfață în Solidity? Care dintre liniile de mai jos sunt valide?

SOLIDITY
interface IVault {
    event Deposited(address indexed user, uint256 amount);
    error ZeroAmount();
    struct Position { uint256 amount; uint64 since; }
    uint256 constant MAX = 100;
    function deposit(uint256 amount) external;
    function position(address u) external view returns (Position memory);
    function _internalHelper() internal;
}

Răspuns scurt: Sunt valide event-ul, eroarea, struct-ul și cele două funcții external fără corp. Nu sunt valide constanta (interfețele nu pot declara variabile, nici constant) și funcția internal (toate funcțiile din interfață trebuie să fie external).

O interfață descrie ce poate fi apelat din exterior, fără implementare. Reguli:

  • funcțiile sunt doar declarate, fără corp, și obligatoriu external;
  • nu pot exista variabile de stare, nici constant, nici constructor, nici modifiers;
  • pot exista event, error, struct, enum;
  • o interfață poate moșteni alte interfețe, dar nu contracte;
  • funcțiile sunt implicit virtual; din 0.8.8, o funcție care implementează o singură funcție de interfață nu mai trebuie marcată override (rămâne obligatoriu dacă suprascrie mai multe baze).

Struct-urile și erorile declarate în interfață se referă prin numele interfeței: IVault.Position, IVault.ZeroAmount. Asta permite unui contract client să decodeze erorile și să folosească tipurile fără să importe implementarea.

Folosire:

SOLIDITY
contract Strategy {
    IVault public immutable vault;
    constructor(IVault v) { vault = v; }
    function invest(uint256 x) external {
        vault.deposit(x);
    }
}

Două utilizări avansate care apar la interviu:

  • type(IVault).interfaceId dă XOR-ul selectorilor funcțiilor, folosit în ERC-165 (supportsInterface) ca un contract să anunțe ce standarde implementează. Atenție: funcțiile moștenite din alte interfețe nu intră în calcul;
  • adresa unui contract se convertește la interfață (IVault(addr)) fără nicio verificare că acel contract chiar o implementează; dacă nu, apelul eșuează la runtime.

Ce urmărește intervievatorul: Se verifică dacă știi exact limitele interfețelor. Mulți candidați cred că pot pune constante sau funcții interne în interfață.

Eroarea, în practică:Functions in interfaces must be declared externalInterfaces can only inherit from other interfaces

49 Junior

Ce face linia using SafeERC20 for IERC20; și cum se schimbă apelurile după ea? Scrie un exemplu cu o bibliotecă proprie.

Răspuns scurt: Atașează funcțiile bibliotecii SafeERC20 tipului IERC20, ca să le poți chema ca metode: token.safeTransfer(to, amount) devine SafeERC20.safeTransfer(token, to, amount). Primul parametru al funcției din bibliotecă primește obiectul din stânga punctului.

using A for B e zahăr sintactic: funcțiile din A al căror prim parametru e de tipul B devin disponibile ca metode pe valori de tip B. Nu schimbă costul și nici nu adaugă stare.

O bibliotecă proprie:

SOLIDITY
library Percent {
    uint256 internal constant BPS = 10_000;
    function bps(uint256 amount, uint256 points) internal pure returns (uint256) {
        return amount * points / BPS;
    }
}

contract Shop {
    using Percent for uint256;
    function fee(uint256 price) external pure returns (uint256) {
        return price.bps(250); // Percent.bps(price, 250)
    }
}

Variante:

  • using Percent for *; atașează funcțiile oricărui tip potrivit;
  • din 0.8.13 poți scrie using {bps} for uint256; cu funcții libere și poți folosi global la nivel de fișier pentru tipuri definite de utilizator, ca atașarea să fie valabilă peste tot unde tipul e importat;
  • din 0.8.19 poți defini operatori (+, ==) pentru tipuri valoare definite de utilizator, tot prin using ... for ... global.

Pentru SafeERC20, rostul e tratarea tokenilor care nu respectă standardul (care nu întorc bool sau întorc false în loc de revert): safeTransfer dă revert dacă transferul nu a reușit.

Domeniul de valabilitate: directiva using dintr-un contract nu se moștenește automat în contractele derivate (din 0.7.0), deci trebuie repetată acolo unde e folosită.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de atașare și de ce e folosit peste tot în OpenZeppelin. Greșeala tipică e să crezi că using adaugă stare sau cost.

Eroarea, în practică:Library name expected (using for)

50 Mid

Care e diferența, la deploy și la runtime, dintre o funcție internal și una public dintr-o bibliotecă? Ce înseamnă „linking”?

Răspuns scurt: Funcțiile internal ale bibliotecii se copiază în bytecode-ul contractului care le folosește și sunt apelate cu salt intern. Funcțiile public/external rămân într-o bibliotecă publicată separat și sunt apelate prin DELEGATECALL; adresa ei trebuie inserată în bytecode-ul contractului la deploy, adică linking.

Bibliotecile sunt contracte fără stare proprie, folosite pentru cod comun. Comportamentul depinde de vizibilitatea funcțiilor folosite.

Funcții internal (cazul cel mai frecvent, inclusiv în OpenZeppelin): compilatorul include codul lor în contract. Nu e nevoie de deploy separat, apelul e ieftin, dar fiecare contract care le folosește își mărește bytecode-ul.

Funcții public sau external: biblioteca e publicată o singură dată, la o adresă proprie. Contractul o apelează prin DELEGATECALL, deci codul bibliotecii rulează în contextul contractului: vede storage-ul lui, msg.sender și msg.value rămân ale apelului original. Costul e al unui apel extern.

La compilare, adresa bibliotecii nu e cunoscută, așa că bytecode-ul conține un placeholder de forma __$<hash>$__. Linking-ul înseamnă înlocuirea placeholder-ului cu adresa reală înainte de deploy:

  • Foundry: forge create ... --libraries src/Lib.sol:Lib:0xAdresa sau setări în foundry.toml;
  • Hardhat: ethers.getContractFactory("C", { libraries: { Lib: addr } }).

Când alegi varianta externă: când contractul se apropie de limita de 24 KB și vrei să muți cod din el, sau când mai multe contracte folosesc același cod mare.

Restricții pentru biblioteci: nu pot avea variabile de stare (doar constant), nu pot moșteni și nu pot fi moștenite, nu pot primi ether. Pot primi parametri storage, ceea ce le face potrivite pentru logică pe structuri de date (de exemplu EnumerableSet).

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului real din spatele bibliotecilor. Mulți candidați nu știu că funcțiile publice ale bibliotecilor folosesc DELEGATECALL.

51 Mid

Contractul de mai jos implementează o interfață. Compilează? Ce înseamnă override pe o variabilă de stare și când scrii override(A, B)?

SOLIDITY
interface ISupply { function totalSupply() external view returns (uint256); }

contract Token is ISupply {
    uint256 public override totalSupply;
}

Răspuns scurt: Compilează: o variabilă de stare public poate implementa o funcție external cu aceeași semnătură, pentru că getter-ul generat are exact acea formă. override(A, B) e obligatoriu când aceeași funcție vine din mai multe baze și trebuie să le numești pe toate.

Regulile de suprascriere din 0.6 încoace sunt explicite: o funcție poate fi suprascrisă doar dacă e marcată virtual, iar cea care o suprascrie trebuie să scrie override. Funcțiile din interfețe sunt implicit virtual.

Variabilele de stare publice au un statut special:

  • pot suprascrie o funcție external cu același nume, parametri și tip returnat, cum e totalSupply() din exemplu;
  • nu pot fi la rândul lor suprascrise (o variabilă de stare nu poate fi virtual);
  • nu pot suprascrie o funcție public, pentru că getter-ul e external.

Când două baze definesc aceeași funcție, contractul derivat trebuie să o suprascrie și să le enumere:

SOLIDITY
contract MyToken is ERC20, ERC20Pausable {
    function _update(address from, address to, uint256 value)
        internal
        override(ERC20, ERC20Pausable)
    {
        super._update(from, to, value);
    }
}

Ordinea din override(...) nu contează, dar lista trebuie să fie completă. super._update apelează următoarea implementare din liniarizare, deci ambele logici rulează. E situația tipică la combinarea extensiilor OpenZeppelin, iar wizard-ul lor generează exact acest cod.

Dacă vrei ca o funcție suprascrisă să poată fi suprascrisă din nou, o marchezi virtual override. Vizibilitatea poate fi schimbată doar de la external la public la suprascriere, iar mutabilitatea doar spre mai strict (de exemplu de la nespecificat la view, de la view la pure).

Ce urmărește intervievatorul: Se verifică regulile exacte de suprascriere, care apar zilnic când combini extensii OpenZeppelin. Candidații uită des că lista din override(...) trebuie să fie completă.

Eroarea, în practică:Function has override but does not override anythingDerived contract must override function

52 Mid

De ce un contract folosit ca implementare în spatele unui proxy nu se poate baza pe constructor? Ce e greșit aici?

SOLIDITY
contract VaultV1 is Initializable, OwnableUpgradeable {
    uint256 public fee;
    constructor() { fee = 30; }
    function initialize(address owner_) public {
        __Ownable_init(owner_);
    }
}

Răspuns scurt: Constructorul rulează doar o dată, pe storage-ul implementării, nu al proxy-ului, deci fee rămâne 0 în proxy. Iar initialize nu are modifier-ul initializer, așa că oricine o poate apela oricând și devine owner. Constructorul implementării trebuie doar să apeleze _disableInitializers().

Un proxy delegă toate apelurile către implementare cu DELEGATECALL: rulează codul implementării, dar pe storage-ul proxy-ului. Constructorul implementării a rulat la deploy-ul ei, pe storage-ul propriu, iar proxy-ul nu vede nimic din ce a scris acolo. De aceea inițializarea se face printr-o funcție obișnuită, apelată prin proxy.

Varianta corectă cu OpenZeppelin Upgradeable:

SOLIDITY
contract VaultV1 is Initializable, OwnableUpgradeable {
    uint256 public fee;

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    function initialize(address owner_) public initializer {
        __Ownable_init(owner_);
        fee = 30;
    }
}

Ce face fiecare parte:

  • initializer permite un singur apel; al doilea dă revert;
  • _disableInitializers() blochează inițializarea implementării înseși, ca un atacator să nu o poată inițializa și deveni owner pe ea (lucru periculos mai ales la UUPS);
  • pentru versiuni noi folosești reinitializer(2), care rulează o singură dată pentru versiunea 2.

Un risc separat: dacă publici proxy-ul și apelezi initialize în tranzacții diferite, un bot poate apela initialize între ele. Proxy-ul trebuie creat cu datele de inițializare în aceeași tranzacție (new ERC1967Proxy(impl, abi.encodeCall(VaultV1.initialize, (owner)))), cum fac automat pluginurile OpenZeppelin Upgrades pentru Foundry și Hardhat.

Variabilele inițializate la declarare (uint256 public fee = 30;) au aceeași problemă: sunt setate de constructor, deci nu ajung în proxy.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului proxy la nivel practic. Inițializatorul neprotejat e una dintre cele mai frecvente vulnerabilități găsite în audituri.

53 Mid

Ai V1 deja în producție, în spatele unui proxy. Ce se strică după upgrade-ul la V2?

SOLIDITY
contract V1 { address public owner; uint256 public total; }

contract V2 {
    uint256 public fee;
    address public owner;
    uint256 public total;
}

Răspuns scurt: Storage-ul proxy-ului rămâne același, dar V2 l-a interpretat altfel: fee citește slotul 0, unde era owner, owner citește slotul 1, unde era total, iar total citește un slot gol. Variabilele noi se adaugă doar la final, fără să schimbi ordinea sau tipurile celor vechi.

Compilatorul atribuie sloturi variabilelor de stare în ordinea declarării, începând de la 0, și le împachetează când încap. Proxy-ul păstrează datele în aceste sloturi. La upgrade se schimbă doar codul, nu și datele, deci noua implementare trebuie să aibă exact același layout pentru variabilele existente.

În exemplu:

  • slotul 0 conține adresa owner-ului din V1, dar V2 îl citește ca fee, deci comisionul devine un număr uriaș;
  • slotul 1 conține total, dar V2 îl citește ca owner, deci owner-ul devine o adresă formată din biții totalului, iar controlul contractului e pierdut;
  • slotul 2 e gol, deci total devine 0.

Varianta corectă:

SOLIDITY
contract V2 {
    address public owner;
    uint256 public total;
    uint256 public fee; // nou, la final
}

Reguli pentru upgrade-uri:

  • nu ștergi, nu reordonezi și nu schimbi tipul variabilelor existente;
  • nu inserezi variabile noi în contractele de bază, pentru că le deplasează pe cele ale copiilor;
  • nu schimbi ordinea moștenirii;
  • poți redenumi o variabilă, pentru că numele nu apare în storage.

Verificarea nu se face din memorie. Pluginul OpenZeppelin Upgrades compară layout-ul vechi cu cel nou și oprește upgrade-ul dacă găsește incompatibilități. Manual poți compara ieșirea forge inspect V1 storageLayout cu cea pentru V2. Testul serios face upgrade pe un fork al rețelei și verifică valorile existente.

Ce urmărește intervievatorul: Se verifică înțelegerea faptului că upgrade-ul schimbă doar codul, nu datele. Greșeala tipică e adăugarea variabilelor noi la începutul contractului sau într-o bază.

54 Senior

Ce problemă rezolvă uint256[50] private __gap; din contractele upgradeable vechi și cu ce a fost înlocuit în OpenZeppelin 5? Explică ERC-7201.

Răspuns scurt: __gap rezervă sloturi într-o bază, ca variabilele noi să nu deplaseze variabilele copiilor. OpenZeppelin 5 folosește namespaced storage (ERC-7201): fiecare modul își ține starea într-un struct, la un slot calculat dintr-un nume unic.

Problema: într-un lanț de moștenire, sloturile se alocă în ordinea liniarizării. Dacă BaseUpgradeable ocupă sloturile 0–2 și copilul ocupă 3–5, adăugarea unei variabile în bază, în V2, mută variabilele copilului cu un slot. Soluția veche a fost o rezervă:

SOLIDITY
contract BaseUpgradeable {
    uint256 public a;
    uint256[49] private __gap; // la adăugarea unei variabile, scazi gap-ul la 48
}

Merge, dar e fragil: trebuie să ții socoteala manual, iar o greșeală strică totul.

ERC-7201 propune ca fiecare modul să-și pună starea într-un struct la o locație derivată dintr-un identificator:

SOLIDITY
/// @custom:storage-location erc7201:myproject.vault
struct VaultStorage {
    uint256 fee;
    mapping(address => uint256) balances;
}

// keccak256(abi.encode(uint256(keccak256("myproject.vault")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant VAULT_SLOT = 0x...; // calculat o dată, scris ca literal

function _vault() private pure returns (VaultStorage storage $) {
    assembly { $.slot := VAULT_SLOT }
}

Formula scade 1 ca preimaginea hash-ului să nu fie cunoscută și maschează ultimul octet ca structul să înceapă la un multiplu de 256, aliniere utilă pentru viitoarele optimizări de storage.

Beneficii: modulele nu se mai ating între ele, ordinea moștenirii nu mai contează pentru layout, iar adăugarea de câmpuri la finalul struct-ului e sigură. Adnotarea @custom:storage-location permite uneltelor să verifice layout-ul. Contractele OpenZeppelin Upgradeable 5 folosesc acest model peste tot, iar codul vechi bazat pe __gap nu poate fi amestecat la upgrade cu cel nou fără migrare atentă.

Ce urmărește intervievatorul: Se verifică experiența reală cu upgrade-uri în proiecte cu moștenire. Diferența dintre gap și namespaced storage e un subiect frecvent pentru roluri mid și senior.

55 Senior

Ce se poate întâmpla dacă publici o implementare UUPS nouă care nu moștenește UUPSUpgradeable sau în care _authorizeUpgrade e goală? Cum te protejezi?

Răspuns scurt: În UUPS, logica de upgrade stă în implementare. Fără UUPSUpgradeable, proxy-ul nu mai poate fi actualizat niciodată. O _authorizeUpgrade neprotejată permite oricui un upgrade la cod propriu. OpenZeppelin verifică proxiableUUID, iar testele acoperă ambele cazuri.

Într-un proxy transparent, funcția de upgrade e în proxy. În UUPS (ERC-1822, cu sloturile din ERC-1967), proxy-ul e minimal, iar upgradeToAndCall e o funcție a implementării. Avantajul e un proxy mai ieftin; dezavantajul e că fiecare implementare nouă trebuie să păstreze corect mecanismul.

Implementarea minimă:

SOLIDITY
contract VaultV2 is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    function _authorizeUpgrade(address newImpl) internal override onlyOwner {}
}

Corpul gol e corect aici, pentru că verificarea e în modifier. Fără onlyOwner, oricine poate apela upgradeToAndCall(maliciousImpl, data).

Cazurile care strică proxy-ul:

  • implementarea nouă nu are upgradeToAndCall, deci nu mai există cale de upgrade. OpenZeppelin verifică, înainte de a schimba implementarea, că noul contract întoarce identificatorul corect din proxiableUUID(), deci un upgrade la un contract fără UUPS dă revert;
  • implementarea însăși poate fi inițializată de un atacator dacă lipsește _disableInitializers(). În versiuni vechi (OpenZeppelin înainte de 4.3.2) asta permitea apelarea directă a lui upgradeToAndCall pe implementare, cu un delegatecall către un contract care face selfdestruct, ceea ce ștergea codul folosit de toate proxy-urile. Modifier-ul onlyProxy din versiunile actuale previne apelul direct.

Ce faci în practică: folosești pluginul OpenZeppelin Upgrades pentru deploy și upgrade, testezi pe un fork upgrade-ul de la versiunea din producție, pui puterea de upgrade în spatele unui multisig și al unui timelock, și verifici în test că un cont oarecare nu poate face upgrade.

Ce urmărește intervievatorul: Se verifică înțelegerea riscurilor specifice UUPS, nu doar diferența față de transparent. Candidații seniori trebuie să știe cum se poate bloca sau prelua un proxy.

56 Senior

Trebuie să creezi câteva mii de seifuri identice, câte unul per utilizator. De ce nu folosești new Vault() și cum funcționează clonele minimale (EIP-1167)?

Răspuns scurt: new Vault() salvează tot bytecode-ul la fiecare deploy. O clonă EIP-1167 are 45 de octeți și face DELEGATECALL la o singură implementare, deci deploy-ul e mult mai ieftin. Fiecare clonă are storage propriu și se inițializează cu initialize.

Costul unui deploy include câte 200 de gaz pentru fiecare octet de cod salvat, plus execuția constructorului. Pentru un contract de 10 KB, doar salvarea codului costă în jur de două milioane de gaz. O clonă minimală are un bytecode fix, cu adresa implementării inclusă în el, care copiază calldata, face DELEGATECALL și întoarce rezultatul.

Cu OpenZeppelin:

SOLIDITY
import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";

contract VaultFactory {
    address public immutable implementation;
    constructor(address impl) { implementation = impl; }

    function create(address owner) external returns (address v) {
        bytes32 salt = keccak256(abi.encode(owner));
        v = Clones.cloneDeterministic(implementation, salt);
        Vault(v).initialize(owner);
    }

    function predict(address owner) external view returns (address) {
        return Clones.predictDeterministicAddress(implementation, keccak256(abi.encode(owner)));
    }
}

Implementarea folosește initialize cu initializer și are _disableInitializers() în constructor, la fel ca în spatele unui proxy.

Compromisuri:

  • fiecare apel către clonă are un DELEGATECALL în plus, deci costă ceva mai mult decât un contract direct;
  • clonele nu sunt upgradeable: adresa implementării e în bytecode. Dacă vrei upgrade-uri comune, folosești proxy-uri beacon, unde toate proxy-urile întreabă un beacon care e implementarea curentă;
  • immutable din implementare e același pentru toate clonele. Pentru parametri per clonă fără storage există variante de clone cu argumente atașate în bytecode (versiunile recente din OpenZeppelin 5.x adaugă cloneWithImmutableArgs).

Folosire tipică: portofele per utilizator, pool-uri create de un factory, colecții NFT pornite dintr-un șablon.

Ce urmărește intervievatorul: Se verifică dacă știi să alegi tiparul de deploy potrivit costului. Greșeala tipică e să uiți că și clona trebuie inițializată și protejată.

Tokeni ERC și OpenZeppelin

57 Junior

Un utilizator vrea să trimită 1,5 USDC prin contractul tău. Ce valoare primește funcția transfer? Unde e bug-ul în codul de mai jos?

SOLIDITY
function payUsd(IERC20 token, address to, uint256 dollars) external {
    token.transferFrom(msg.sender, to, dollars * 1e18);
}

Răspuns scurt: decimals() e doar o convenție de afișare: USDC are 6 zecimale, deci 1,5 USDC înseamnă 1_500_000 de unități. Codul presupune 18 zecimale pentru orice token și, cu USDC, ar încerca să transfere de 10^12 ori mai mult decât trebuie.

Tokenii ERC-20 lucrează doar cu întregi. decimals() spune aplicațiilor câte zecimale să afișeze: un sold de 1500000 cu decimals = 6 se afișează 1,5. Contractul tokenului nu folosește decimals în niciun calcul.

Majoritatea tokenilor au 18 zecimale, ca ether-ul, dar nu toți: USDC și USDT au 6, WBTC are 8. Funcția din exemplu calculează 1 * 1e18 pentru un dolar; cu USDC, cererea e de 10^12 dolari și eșuează, iar cu un token cu mai multe zecimale ar trimite sume greșite.

Corectura:

SOLIDITY
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

function payUsd(IERC20Metadata token, address to, uint256 dollars) external {
    uint256 amount = dollars * 10 ** token.decimals();
    SafeERC20.safeTransferFrom(token, msg.sender, to, amount);
}

decimals() face parte din extensia opțională de metadate, nu din interfața de bază, deci unele tokeni foarte vechi pot să nu o aibă. Pentru tokeni cunoscuți, se salvează de obicei zecimalele la configurare.

În aplicație, ethers v6:

JavaScript
const amount = ethers.parseUnits("1.5", 6); // 1500000n
const shown = ethers.formatUnits(balance, await token.decimals());

În protocoale care combină mai mulți tokeni (de exemplu prețuri sau colateral), normalizezi totul la aceeași scară, de obicei 18 zecimale, înainte de calcule, și revii la zecimalele tokenului doar la transfer.

Ce urmărește intervievatorul: Se verifică înțelegerea rolului real al zecimalelor. Codarea fixă a valorii 1e18 e unul dintre cele mai frecvente bug-uri la integrarea de stablecoin-uri.

58 Junior

Scrie funcțiile de mint și burn pentru un ERC-20 bazat pe OpenZeppelin 5. Ce events se emit și cum le recunoaște un explorer ca mint sau burn?

Răspuns scurt: Folosești funcțiile interne _mint(to, amount) și _burn(from, amount). Ambele emit Transfer: mint-ul ca transfer de la address(0), burn-ul ca transfer către address(0). După aceste adrese, explorerele și indexerele le identifică.

Standardul ERC-20 nu definește funcții de mint sau burn, doar cere ca orice creare de tokeni să emită Transfer cu from = address(0). Implementarea OpenZeppelin respectă asta automat.

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

contract Points is ERC20, Ownable {
    constructor(address owner_) ERC20("Points", "PTS") Ownable(owner_) {}

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

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

Ce se întâmplă în spate: _mint crește totalSupply și soldul destinatarului, _burn le scade pe amândouă, iar _burn dă revert dacă soldul e insuficient (eroarea ERC20InsufficientBalance). Ambele trec prin funcția internă _update, care emite Transfer.

Detalii importante:

  • burn arde doar din propriul sold. Pentru a arde tokenii altcuiva ai nevoie de aprobare; extensia ERC20Burnable oferă burnFrom, care consumă allowance-ul, ca la transferFrom;
  • _mint către address(0) dă revert, deci nu poți crea tokeni pierduți din greșeală;
  • un plafon de emisie se pune cu extensia ERC20Capped, nu cu verificări manuale împrăștiate.

La ERC-721 regula e aceeași (Transfer(address(0), to, tokenId)), iar la ERC-1155 se emite TransferSingle sau TransferBatch, tot cu from sau to egal cu address(0).

Când tokenii trebuie retrași de la cineva fără acordul lui, discuția devine de produs și de încredere: un contract care poate arde din orice cont e văzut de utilizatori ca un risc.

Ce urmărește intervievatorul: Se verifică cunoașterea convenției de mint și burn și a implementării OpenZeppelin 5. Greșeala tipică e un burn(address from, uint256) public, fără verificări.

Eroarea, în practică:ERC20InvalidReceiver(0x0000...0000)

59 Junior

Un utilizator semnează pe un site o tranzacție setApprovalForAll(0xabc..., true) pentru colecția lui de NFT-uri. Ce a aprobat de fapt și de ce e diferit de approve?

Răspuns scurt: A dat adresei 0xabc... dreptul de a transfera toate NFT-urile lui din colecție, inclusiv pe cele primite în viitor, până revocă. approve(to, tokenId) dă drept doar pentru un singur token și se anulează automat la transferul acelui token.

ERC-721 are două niveluri de aprobare:

  • approve(address to, uint256 tokenId): un singur cont aprobat per token; se șterge când tokenul își schimbă proprietarul. Se citește cu getApproved(tokenId);
  • setApprovalForAll(address operator, bool approved): operatorul poate muta orice token al proprietarului din acea colecție, fără limită de număr sau timp. Se citește cu isApprovedForAll(owner, operator).

ERC-1155 are doar varianta „pentru tot”, cu aceeași semnătură.

Marketplace-urile folosesc setApprovalForAll ca să poată executa vânzări fără o nouă aprobare pentru fiecare listare. E comod, dar înseamnă că un operator compromis sau rău-intenționat poate goli toată colecția. Multe atacuri de phishing cer exact această semnătură, prezentată ca „verificare” sau „mint gratuit”.

În contract, transferul verifică ambele drepturi:

SOLIDITY
// logica din OpenZeppelin ERC721, simplificat
function _isAuthorized(address owner, address spender, uint256 tokenId) internal view returns (bool) {
    return spender != address(0) &&
        (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
}

Ce spui la interviu despre partea de produs: interfața trebuie să explice clar ce aprobă utilizatorul, aplicațiile ar trebui să ceară aprobări cât mai restrânse, iar utilizatorii își revocă aprobările vechi (prin aceeași funcție, cu false, sau prin unelte de tip revoke din explorere).

În teste verifici că după setApprovalForAll(op, false) operatorul nu mai poate transfera și că event-ul ApprovalForAll e emis corect.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de aprobări NFT și a riscului real pentru utilizatori. Mulți candidați nu știu că aprobarea globală acoperă și tokenii viitori.

Eroarea, în practică:ERC721InsufficientApproval(operator, tokenId)

60 Junior

De ce folosești OpenZeppelin în loc să scrii singur un ERC-20? Cum îl instalezi într-un proiect Foundry și într-unul Hardhat și ce verifici la versiune?

Răspuns scurt: Implementările OpenZeppelin sunt auditate, testate în producție de multe proiecte și urmează exact standardele, inclusiv cazurile limită. În Foundry instalezi cu forge install OpenZeppelin/openzeppelin-contracts, în Hardhat cu npm install @openzeppelin/contracts. Fixezi versiunea, pentru că între 4.x și 5.x API-ul s-a schimbat.

Un ERC-20 pare simplu, dar implementarea corectă are multe detalii: events pentru fiecare schimbare, erori standard (ERC-6093 în versiunea 5), tratarea address(0), aprobări infinite care nu se consumă, compatibilitate cu extensii precum permit, votare sau pauză. Codul scris de la zero trebuie auditat separat și va fi privit cu suspiciune de integratori.

Instalare Foundry:

BASH
forge install OpenZeppelin/openzeppelin-contracts@v5.1.0

În remappings.txt:

@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/

Instalare Hardhat:

BASH
npm install @openzeppelin/contracts@5.1.0

Importurile arată la fel în ambele: import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";.

Ce verifici la versiune:

  • 5.x cere Solidity 0.8.20 sau mai nou (și setarea de EVM corespunzătoare rețelei), are Ownable(initialOwner) cu argument, a înlocuit hook-urile _beforeTokenTransfer cu _update și a mutat unele fișiere (de exemplu Pausable și ReentrancyGuard în utils/);
  • contractele upgradeable sunt într-un pachet separat, @openzeppelin/contracts-upgradeable, cu aceeași versiune ca pachetul principal;
  • versiunea fixată exact, nu un interval, ca build-ul să fie reproductibil și verificarea pe explorer să reușească.

Alternativ, Solady și Solmate oferă implementări optimizate pentru gaz, cu compromisuri de siguranță și ergonomie. Pentru interviu, OpenZeppelin e răspunsul implicit, iar abaterea de la el trebuie justificată.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat cu biblioteca în proiecte reale și știi diferențele dintre versiuni. Codul de tutorial pentru versiunea 4 care nu compilează cu 5 e o greșeală frecventă la temele de interviu.

Eroarea, în practică:Source "@openzeppelin/..." not found

61 Mid

Vrei un ERC-20 în care niciun portofel să nu poată deține mai mult de 1% din ofertă, cu excepția trezoreriei. Unde pui regula în OpenZeppelin 5?

Răspuns scurt: Suprascrii funcția internă _update(from, to, value), prin care trec toate transferurile, mint-urile și burn-urile. Apelezi super._update, apoi verifici soldul lui to, sărind peste address(0) și trezorerie. În 5.x hook-urile _beforeTokenTransfer și _afterTokenTransfer nu mai există.

În versiunea 4, extensiile se legau prin _beforeTokenTransfer și _afterTokenTransfer. Versiunea 5 a simplificat totul într-o singură funcție, _update: mint înseamnă from == address(0), burn înseamnă to == address(0), altfel e transfer. transfer, transferFrom, _mint și _burn ajung toate aici.

SOLIDITY
contract CappedHolding is ERC20 {
    address public immutable treasury;
    error HoldingLimit(address account, uint256 balance);

    constructor(address t) ERC20("Capped", "CAP") {
        treasury = t;
        _mint(t, 1_000_000e18);
    }

    function _update(address from, address to, uint256 value) internal override {
        super._update(from, to, value);
        if (to != address(0) && to != treasury) {
            uint256 limit = totalSupply() / 100;
            uint256 bal = balanceOf(to);
            if (bal > limit) revert HoldingLimit(to, bal);
        }
    }
}

De ce verificarea după super._update: soldul final e cel relevant și include deja suma transferată. Nu rescrii logica de transfer, doar adaugi o regulă.

Puncte de discuție:

  • limita e ușor de ocolit prin împărțirea pe mai multe adrese, deci e o regulă de produs, nu de securitate;
  • un pool de lichiditate (de exemplu o pereche AMM) va acumula mult mai mult de 1%; trebuie o listă de excepții administrată;
  • orice logică în _update se execută la fiecare transfer, deci crește costul de gaz pentru toți;
  • tokenii cu reguli de transfer neobișnuite sunt mai greu de integrat în protocoale.

Același model se folosește pentru pauză (ERC20Pausable), votare (ERC20Votes) sau blocarea adreselor.

Ce urmărește intervievatorul: Se verifică dacă știi punctul de extensie corect în OpenZeppelin 5. Mulți candidați caută încă _beforeTokenTransfer sau suprascriu transfer și uită de transferFrom.

62 Mid

Implementează un NFT netransferabil (soulbound), de exemplu o diplomă, cu OpenZeppelin 5. Proprietarul contractului emite diplome, iar cursantul nu le poate muta.

Răspuns scurt: Moștenești ERC721 și suprascrii _update(to, tokenId, auth): citești proprietarul curent cu _ownerOf, iar dacă atât sursa, cât și destinația sunt nenule, dai revert. Mint-ul (sursă zero) și, opțional, burn-ul (destinație zero) rămân permise.

În ERC721 din versiunea 5, toate mutările de tokeni trec prin _update(address to, uint256 tokenId, address auth), care întoarce proprietarul anterior. E locul unic unde blochezi transferurile:

SOLIDITY
contract Diploma is ERC721, Ownable {
    uint256 private _nextId;
    error Soulbound();

    constructor(address owner_) ERC721("Diploma", "DIP") Ownable(owner_) {}

    function issue(address student) external onlyOwner returns (uint256 id) {
        id = _nextId++;
        _mint(student, id);
    }

    function _update(address to, uint256 tokenId, address auth)
        internal override returns (address)
    {
        address from = _ownerOf(tokenId);
        if (from != address(0) && to != address(0)) revert Soulbound();
        return super._update(to, tokenId, auth);
    }
}

issue folosește _mint, nu _safeMint, pentru că emitentul e de încredere și nu e nevoie de callback; dacă destinatarii pot fi contracte, _safeMint verifică dacă le pot primi.

Decizii de discutat:

  • permiți burn? Dacă da, cine: cursantul (ca să renunțe) sau emitentul (ca să revoce o diplomă acordată greșit);
  • aprobările (approve, setApprovalForAll) încă se pot apela, dar nu au efect; unele implementări le blochează și pe ele, ca interfețele să nu inducă în eroare;
  • ERC-5192 definește un event Locked(tokenId) și o funcție locked(tokenId), prin care marketplace-urile și portofelele recunosc tokenii blocați;
  • pierderea cheii înseamnă pierderea diplomei; un emitent poate oferi reemitere, cu burn la vechiul token.

În teste verifici că mint-ul merge, că transferFrom și safeTransferFrom dau Soulbound și că tokenURI funcționează.

Ce urmărește intervievatorul: Se verifică dacă știi să extinzi corect un standard prin punctul de extensie potrivit. Greșeala tipică e suprascrierea doar a lui transferFrom, lăsând safeTransferFrom deschis.

63 Mid

Unde e vulnerabilitatea în funcția de mint de mai jos? Limita este de 5 NFT-uri per portofel.

SOLIDITY
function mint(uint256 n) external payable {
    require(msg.value == n * PRICE, "pret");
    require(minted[msg.sender] + n <= 5, "limita");
    for (uint256 i; i < n; i++) {
        _safeMint(msg.sender, nextId++);
    }
    minted[msg.sender] += n;
}

Răspuns scurt: _safeMint apelează onERC721Received pe destinatar, dacă acesta e contract, înainte ca minted să fie actualizat. Un contract atacator reintră în mint din callback și trece mereu de verificarea limitei. Mută minted[msg.sender] += n înainte de buclă și adaugă nonReentrant.

_safeMint există ca NFT-urile să nu ajungă în contracte care nu le pot gestiona: după mint, dacă destinatarul are cod, i se apelează onERC721Received, iar dacă nu răspunde corect, se dă revert. Acel apel e un apel extern către cod controlat de utilizator, deci o oportunitate de reentrancy.

Atacul:

SOLIDITY
contract Attacker is IERC721Receiver {
    NFT nft; uint256 count;
    function start() external payable { nft.mint{value: 5 * PRICE}(5); }
    function onERC721Received(address, address, uint256, bytes calldata)
        external returns (bytes4)
    {
        if (++count < 50 && address(this).balance >= 5 * PRICE) {
            nft.mint{value: 5 * PRICE}(5); // minted[this] încă e 0
        }
        return this.onERC721Received.selector;
    }
}

La fiecare reintrare, minted[attacker] e încă 0, deci verificarea trece. Atacatorul plătește prețul, dar ocolește limita și poate cumpăra o parte mare din colecție la lansare.

Repararea, după checks-effects-interactions:

SOLIDITY
function mint(uint256 n) external payable nonReentrant {
    if (msg.value != n * PRICE) revert WrongPrice();
    if (minted[msg.sender] + n > 5) revert LimitReached();
    minted[msg.sender] += n;           // efectul înainte de apelurile externe
    uint256 id = nextId;
    nextId = id + n;
    for (uint256 i; i < n; i++) {
        _safeMint(msg.sender, id + i);
    }
}

Și nextId e actualizat înainte, pentru același motiv. Aceleași callback-uri există la ERC-1155 (onERC1155Received) și la tokeni ERC-777, deci orice transfer „safe” trebuie tratat ca apel extern.

Ce urmărește intervievatorul: Se verifică dacă recunoști reentrancy-ul ascuns într-un apel care nu pare extern. Mulți candidați nu știu că _safeMint apelează destinatarul.

64 Mid

Un token are nevoie de trei roluri: administrator, minter și pauser, cu mai multe persoane per rol. Cum implementezi cu AccessControl și de ce nu ajunge Ownable?

Răspuns scurt: Ownable are un singur proprietar cu toate drepturile. AccessControl definește roluri ca bytes32, fiecare cu membri multipli și cu un rol administrator care le acordă și le revocă. Protejezi funcțiile cu onlyRole(MINTER_ROLE).

Separarea rolurilor reduce paguba dacă o cheie e compromisă: cheia unui bot care emite recompense nu trebuie să poată schimba și setările critice.

SOLIDITY
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";

contract Reward is ERC20, ERC20Pausable, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    constructor(address admin) ERC20("Reward", "RWD") {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
    function pause() external onlyRole(PAUSER_ROLE) { _pause(); }
    function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) { _unpause(); }

    function _update(address f, address t, uint256 v)
        internal override(ERC20, ERC20Pausable) { super._update(f, t, v); }
}

Administratorul acordă roluri cu grantRole(MINTER_ROLE, bot). Fiecare rol are un rol admin, implicit DEFAULT_ADMIN_ROLE, schimbabil cu _setRoleAdmin. Events RoleGranted și RoleRevoked permit auditarea istoricului.

Ce urmărești:

  • DEFAULT_ADMIN_ROLE e cel mai puternic; îl ține un multisig, nu o cheie personală, iar AccessControlDefaultAdminRules adaugă un transfer în doi pași cu întârziere;
  • AccessControl simplu nu permite listarea membrilor; AccessControlEnumerable da, cu cost de gaz mai mare;
  • renounceRole permite unei chei compromise să renunțe singură la drepturi;
  • pentru un singur proprietar, Ownable2Step e mai sigur decât Ownable, pentru că noul proprietar trebuie să accepte, deci o adresă greșită nu blochează contractul.

Ce urmărește intervievatorul: Se verifică dacă știi să proiectezi permisiuni granulare. Greșeala tipică e un singur owner cu toate drepturile, ținut într-o cheie personală.

Eroarea, în practică:OwnableUnauthorizedAccount(address)AccessControlUnauthorizedAccount

65 Mid

Un joc are monede (fungibile) și săbii unice în același contract ERC-1155. Cum emiți mai multe tipuri într-o singură tranzacție și cum funcționează uri(id) cu {id}?

Răspuns scurt: Folosești _mintBatch(to, ids, amounts, data), care emite TransferBatch și apelează onERC1155BatchReceived dacă destinatarul e contract. uri(id) întoarce de obicei același șablon pentru toate id-urile, iar clientul înlocuiește {id} cu id-ul în hex, pe 64 de caractere, cu litere mici.

ERC-1155 ține soldurile ca balanceOf(account, id): un id cu oferta 1 se comportă ca un NFT, unul cu oferta mare ca un token fungibil. Operațiile în lot reduc costul când se mută mai multe tipuri deodată.

SOLIDITY
import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";

contract Game is ERC1155, Ownable {
    uint256 public constant GOLD = 0;
    uint256 public constant SWORD_1 = 1;

    constructor(address o) ERC1155("https://game.example/items/{id}.json") Ownable(o) {}

    function starterPack(address player) external onlyOwner {
        uint256[] memory ids = new uint256[](2);
        uint256[] memory amounts = new uint256[](2);
        ids[0] = GOLD;    amounts[0] = 100;
        ids[1] = SWORD_1; amounts[1] = 1;
        _mintBatch(player, ids, amounts, "");
    }
}

Funcții standard: safeTransferFrom(from, to, id, amount, data), safeBatchTransferFrom, balanceOfBatch(accounts, ids), setApprovalForAll. Nu există transferuri fără verificare: toate sunt „safe”, deci toate apelează destinatarul dacă e contract.

Despre URI: standardul cere ca, dacă textul conține {id}, clientul să-l înlocuiască cu id-ul în hexazecimal, cu zerouri la stânga până la 64 de caractere. Pentru id 1, fișierul căutat e .../0000...0001.json. Un URI unic per token se poate întoarce suprascriind uri(id) sau folosind extensia ERC1155URIStorage.

Ce discuți: unicitatea săbiei nu e garantată de standard; trebuie să ai grijă ca id-ul 1 să nu mai fie emis niciodată (de exemplu cu ERC1155Supply și verificarea totalSupply(id)). Callback-urile la fiecare transfer sunt puncte de reentrancy, ca la _safeMint.

Ce urmărește intervievatorul: Se verifică experiența practică cu ERC-1155 dincolo de comparația cu ERC-721. Mulți candidați nu știu regula de formatare pentru {id}.

66 Mid

Când ai adăuga posibilitatea de a pune pe pauză un contract și ce funcții lași să meargă și în pauză? Cum arată asta cu OpenZeppelin 5?

Răspuns scurt: Pauza e un buton de urgență pentru momentul în care descoperi un bug sau un atac în curs. Cu Pausable (în 5.x la utils/Pausable.sol) pui whenNotPaused pe funcțiile riscante. De obicei lași retragerea fondurilor proprii posibilă și în pauză, ca utilizatorii să nu fie blocați.

Pausable oferă o variabilă paused, funcțiile interne _pause() și _unpause(), modifiers whenNotPaused și whenPaused, și events Paused și Unpaused.

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

contract Vault is Pausable, AccessControl, ReentrancyGuard {
    function deposit() external payable whenNotPaused { /* ... */ }
    function borrow(uint256 a) external whenNotPaused nonReentrant { /* ... */ }

    // rămâne activă: utilizatorii își pot scoate fondurile proprii
    function withdraw(uint256 a) external nonReentrant { /* ... */ }

    function pause() external onlyRole(GUARDIAN_ROLE) { _pause(); }
    function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) { _unpause(); }
}

Cum alegi ce oprești: funcțiile prin care cineva poate scoate mai mult decât i se cuvine (împrumuturi, lichidări, swap-uri, mint) se opresc. Funcțiile care doar returnează utilizatorului banii proprii rămân active, cu excepția cazului în care bug-ul e chiar în ele.

Roluri separate: pauza trebuie să fie rapidă, deci o poate da un rol „guardian” cu o cheie la îndemână sau un sistem de monitorizare automat. Reluarea e o decizie mai grea, deci o ia administratorul (multisig), eventual după un timelock.

Compromisuri de discutat:

  • o pauză fără limită de timp înseamnă că administratorul poate bloca fondurile tuturor; unele protocoale limitează durata pauzei;
  • integrările externe care depind de contract se pot strica în pauză;
  • pauza nu repară bug-ul, doar câștigă timp pentru upgrade sau migrare.

Ce urmărește intervievatorul: Se verifică gândirea operațională, nu doar sintaxa. Greșeala tipică e blocarea și a retragerilor, ceea ce transformă un incident în pierderea încrederii utilizatorilor.

Eroarea, în practică:EnforcedPause

67 Senior

Un contract de staking distribuie rewardRate tokeni pe secundă, proporțional cu suma blocată. De ce nu iterezi peste toți utilizatorii și cum calculezi recompensele în cost constant?

Răspuns scurt: Iterarea are cost nelimitat și blochează contractul când lista crește. Folosești un acumulator global, rewardPerTokenStored, crescut cu timp * rewardRate * 1e18 / totalStaked, și salvezi pentru fiecare utilizator valoarea lui la ultima actualizare.

Ideea, popularizată de contractul StakingRewards al Synthetix: recompensa unui utilizator este soldul lui înmulțit cu cât a crescut „recompensa per token” de când l-ai văzut ultima dată.

SOLIDITY
uint256 public rewardPerTokenStored;
uint256 public lastUpdate;
uint256 public totalStaked;
mapping(address => uint256) public staked;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;

function rewardPerToken() public view returns (uint256) {
    if (totalStaked == 0) return rewardPerTokenStored;
    return rewardPerTokenStored +
        (block.timestamp - lastUpdate) * rewardRate * 1e18 / totalStaked;
}

function earned(address u) public view returns (uint256) {
    return staked[u] * (rewardPerToken() - userRewardPerTokenPaid[u]) / 1e18 + rewards[u];
}

modifier updateReward(address u) {
    rewardPerTokenStored = rewardPerToken();
    lastUpdate = block.timestamp;
    rewards[u] = earned(u);
    userRewardPerTokenPaid[u] = rewardPerTokenStored;
    _;
}

function stake(uint256 a) external updateReward(msg.sender) { /* actualizezi staked, totalStaked, transferi */ }
function withdraw(uint256 a) external updateReward(msg.sender) { /* ... */ }
function claim() external updateReward(msg.sender) { /* plătești rewards[msg.sender] */ }

De ce funcționează: între două interacțiuni, soldurile nu se schimbă, deci recompensa fiecăruia e proporțională cu creșterea acumulatorului în acel interval. Fiecare operație actualizează doar starea globală și pe cea a apelantului.

Cazuri limită:

  • totalStaked == 0: recompensele din acea perioadă nu se distribuie nimănui; decizi dacă sunt pierdute sau reportate;
  • precizia: cu un totalStaked foarte mare și un rewardRate mic, termenul se rotunjește la zero; scalarea cu 1e18 sau mai mult reduce problema;
  • solvabilitatea: contractul trebuie să aibă destui tokeni de recompensă pentru rewardRate * durata, verificat la setarea ratei;
  • tokenul de staking și cel de recompensă identice complică socoteala soldului.

Ce urmărește intervievatorul: Se verifică stăpânirea unui tipar fundamental din DeFi. Candidații care propun iterarea peste utilizatori nu au lucrat cu limitele de gaz.

68 Senior

Explică atacul de inflație asupra primului depozitar într-un vault ERC-4626 și cum îl previi.

SOLIDITY
function deposit(uint256 assets, address to) external returns (uint256 shares) {
    shares = totalSupply() == 0 ? assets : assets * totalSupply() / totalAssets();
    asset.transferFrom(msg.sender, address(this), assets);
    _mint(to, shares);
}

Răspuns scurt: Atacatorul depune 1 wei, apoi transferă direct o sumă mare, umflând totalAssets(). Victima primește 0 shares prin rotunjire, iar atacatorul ia fondurile. Prevenire: virtual shares (OpenZeppelin 4.9+), shares moarte la deploy, minim de shares primite.

totalAssets() se bazează de obicei pe asset.balanceOf(address(this)), care poate fi crescut de oricine printr-un transfer direct, fără mint de shares.

Pașii atacului, într-un vault nou:

  • atacatorul depune 1 wei, primește 1 share;
  • vede în mempool o depunere de 10.000 de tokeni a victimei și, înaintea ei, transferă direct 10.000 de tokeni în vault;
  • victima primește 10_000e18 * 1 / (10_000e18 + 1), adică 0 shares, iar tokenii ei intră în vault;
  • atacatorul răscumpără singurul share și ia aproape tot.

Chiar fără rezultat zero, rotunjirea în jos îi poate lua victimei o fracțiune semnificativă.

Prevenirea:

  • virtual shares și virtual assets: formula adaugă o constantă la numărător și numitor, assets * (totalSupply() + 10**offset) / (totalAssets() + 1). Atacul devine neprofitabil, pentru că donația atacatorului se împarte cu shares virtuale pe care nu le deține. OpenZeppelin ERC4626 face asta din 4.9, iar _decimalsOffset() crește protecția;
  • deployerul face o primă depunere și trimite shares-urile la o adresă moartă, ca vault-ul să nu fie niciodată gol;
  • utilizatorul sau routerul impune un minim de shares primite (protecție de slippage), iar depunerea dă revert dacă nu e atins;
  • contabilitatea internă a activelor, în loc de balanceOf, elimină donațiile directe din calcul, cu prețul că donațiile legitime (de exemplu randamentul) trebuie tratate explicit.

Codul din întrebare are și alte probleme: transferFrom fără SafeERC20 și ordine nepotrivită pentru tokenii cu callback-uri.

Ce urmărește intervievatorul: Se verifică cunoașterea unui atac real asupra unui standard foarte folosit. Un candidat senior trebuie să explice și de ce funcționează mitigarea, nu doar s-o numească.

Optimizarea gazului

69 Junior

Ordonează operațiile de mai jos de la cea mai ieftină la cea mai scumpă și explică diferența dintre accesul „cold” și „warm”: citire din memory, citire din storage, scriere într-un slot de storage gol, scriere într-un slot deja nenul, emiterea unui event.

Răspuns scurt: Ordinea: memory (câțiva gaz), citire din storage (100 warm, 2100 cold), event (sute), scriere peste valoare nenulă (2900, plus 2100 cold), scriere în slot gol (20000, plus 2100 cold). Primul acces la un slot într-o tranzacție e „cold”, următoarele „warm”.

Valorile sunt cele de după upgrade-urile Berlin (EIP-2929) și London (EIP-3529) pe Ethereum:

  • MLOAD/MSTORE: 3 gaz, plus costul de extindere a memoriei, care crește pătratic dacă folosești multă memorie;
  • SLOAD: 2100 la primul acces la un slot în tranzacție (cold), 100 la următoarele (warm);
  • SSTORE din zero în nenul: 20000, plus 2100 dacă slotul e cold;
  • SSTORE din nenul în alt nenul: 2900, plus 2100 cold;
  • SSTORE din nenul în zero: costă ca o modificare, dar dă și un refund (în prezent 4800), limitat la o cincime din gazul tranzacției;
  • LOG: 375 de bază, 375 pe topic, 8 pe octet de date;
  • apel către o adresă cold: 2600 în plus; warm: 100.

Accesul cold/warm a apărut ca să reflecte costul real al citirii din baza de date a nodului: primul acces încarcă datele, următoarele le găsesc deja în cache. Lista de acces (EIP-2930) permite declararea în avans a sloturilor și adreselor, plătind un preț mai mic.

Consecințe practice:

  • citești o variabilă de stare o dată într-o variabilă locală, dacă o folosești de mai multe ori;
  • crearea unei intrări noi (un utilizator nou într-un mapping) e cea mai scumpă operație obișnuită, deci primul depozit al unui utilizator costă mult mai mult decât următoarele;
  • events sunt mult mai ieftine decât storage-ul pentru date pe care contractul nu le citește.

Tranzacția mai plătește 21000 de bază și 16 gaz pe octet nenul de calldata (4 pe octet zero).

Ce urmărește intervievatorul: Se verifică intuiția de cost, fundamentul oricărei optimizări. Greșeala tipică e optimizarea calculului în memory în timp ce codul scrie inutil în storage.

70 Junior

Cum afli cât gaz consumă o funcție înainte de a lansa contractul și cum urmărești dacă o modificare a crescut costul? De ce poate varia costul aceleiași funcții?

Răspuns scurt: În Foundry: forge test --gas-report pentru un tabel pe funcții și forge snapshot --diff pentru comparația cu referința. În Hardhat: hardhat-gas-reporter. Costul variază după stare: sloturi goale, accese cold sau warm, lungimea datelor, ramurile de cod.

Instrumentele:

  • forge test --gas-report: pentru fiecare contract și funcție, minimul, media, mediana și maximul de gaz observate în teste;
  • forge snapshot: scrie .gas-snapshot cu gazul fiecărui test; forge snapshot --diff arată ce s-a schimbat față de ultima versiune salvată, util în code review și în CI (--check face build-ul să eșueze dacă diferă);
  • vm.startSnapshotGas("nume") și vm.stopSnapshotGas() în versiunile recente de Foundry, pentru a măsura o secțiune anume;
  • hardhat-gas-reporter în Hardhat, cu estimare în monedă dacă îi dai un preț;
  • cast estimate sau eth_estimateGas pe o rețea reală sau pe un fork, pentru o tranzacție concretă.

De ce variază:

  • primul stake al unui utilizator scrie în sloturi goale (20000 per slot), următoarele doar modifică valori;
  • primul acces la un slot sau o adresă în tranzacție e cold;
  • buclele depind de lungimea datelor;
  • un utilizator care primește un refund (de exemplu își golește soldul) plătește mai puțin;
  • ramurile if diferite au costuri diferite.

De aceea testele pentru gaz acoperă cazurile reprezentative: primul utilizator, un utilizator existent, cazul cel mai rău. Un raport doar pe drumul fericit dă o imagine falsă.

Costul în bani depinde de prețul gazului din rețea în momentul tranzacției, iar pe un L2 se adaugă costul publicării datelor pe Ethereum, care nu apare în raportul local.

Ce urmărește intervievatorul: Se verifică dacă măsori înainte să optimizezi. Mulți candidați nu știu de forge snapshot sau cred că o funcție are un cost fix.

71 Junior

Câte sloturi de storage ocupă fiecare struct? Cum le-ai reordona?

SOLIDITY
struct A {
    uint128 amount;
    uint256 total;
    uint128 reward;
}
struct B {
    bool active;
    address user;
    uint64 since;
    uint256 id;
}

Răspuns scurt: A ocupă 3 sloturi, pentru că uint256 nu încape lângă uint128 și le separă; reordonat (amount, reward, total) ocupă 2. B ocupă deja 2: bool (1 octet), address (20) și uint64 (8) încap împreună în 32 de octeți, iar id ia un slot propriu.

Un slot are 32 de octeți. Compilatorul așază variabilele în ordinea declarării; dacă următoarea încape în spațiul rămas în slotul curent, o pune acolo, altfel începe un slot nou. Struct-urile și array-urile încep mereu un slot nou, iar mapping-urile și array-urile dinamice ocupă un slot propriu pentru lungime sau marcaj.

Pentru A:

  • amount (16 octeți) intră în slotul 0;
  • total (32) nu mai încape, deci trece în slotul 1;
  • reward (16) nu încape în slotul 1, deci trece în slotul 2.

Reordonat:

SOLIDITY
struct A {
    uint128 amount;  // slot 0, octeții 0-15
    uint128 reward;  // slot 0, octeții 16-31
    uint256 total;   // slot 1
}

Pentru B: 1 + 20 + 8 = 29 de octeți, deci slotul 0; id în slotul 1.

Când merită:

  • câmpurile împachetate se citesc și se scriu împreună; o scriere la amount și reward în aceeași funcție costă un singur SSTORE;
  • dacă un câmp mic e folosit singur, compilatorul trebuie să citească slotul, să mascheze biții și să scrie înapoi, deci operațiile pe tipuri mici pot costa câțiva gaz în plus;
  • tipurile mai mici trebuie alese realist: uint64 pentru timestamp e suficient, uint128 pentru sume de tokeni de obicei e suficient, dar trebuie verificat cu SafeCast la conversie.

forge inspect Contract storageLayout arată sloturile și offset-urile reale, deci verifici, nu ghicești.

Ce urmărește intervievatorul: Se verifică dacă știi regulile de împachetare și când contează. Greșeala tipică e să crezi că uint8 în locul lui uint256 economisește mereu gaz.

72 Junior

Cum ai optimiza funcția de mai jos? Explică fiecare schimbare.

SOLIDITY
uint256[] public scores;
uint256 public total;

function addAll(uint256 bonus) external {
    for (uint256 i = 0; i < scores.length; i++) {
        scores[i] = scores[i] + bonus;
        total = total + bonus;
    }
}

Răspuns scurt: Citești scores.length o dată în afara buclei, acumulezi suma într-o variabilă locală și scrii total o singură dată la final. Așa elimini un SLOAD pentru lungime și o pereche SLOAD/SSTORE pentru total la fiecare iterație.

În varianta originală, la fiecare iterație se fac:

  • un SLOAD pentru scores.length, la condiția buclei;
  • un SLOAD și un SSTORE pentru scores[i], inevitabile;
  • un SLOAD și un SSTORE pentru total.

Scrierile repetate în același slot sunt warm după prima, dar tot costă: aproximativ 100 pentru citire și câteva sute pentru scriere de fiecare dată.

Varianta optimizată:

SOLIDITY
function addAll(uint256 bonus) external {
    uint256 len = scores.length;
    for (uint256 i; i < len; ++i) {
        scores[i] += bonus;
    }
    total += bonus * len;
}

Ce s-a schimbat:

  • lungimea se citește o dată; condiția compară cu o variabilă de pe stivă;
  • total se calculează direct și se scrie o singură dată;
  • inițializarea i = 0 e redundantă, pentru că variabila pornește oricum de la 0;
  • ++i în loc de i++; cu optimizatorul activ diferența e de obicei neglijabilă, dar e convenția obișnuită.

Ce nu se schimbă: funcția tot iterează peste un array de mărime nelimitată. Peste o anumită lungime, tranzacția nu mai încape într-un bloc. Optimizarea reală e de design: în loc să aduni bonusul la fiecare element, păstrezi un globalBonus și calculezi scorul efectiv la citire (scores[i] + globalBonus), ceea ce face funcția O(1).

Orice optimizare o verifici cu forge snapshot --diff, ca să vezi câștigul real.

Ce urmărește intervievatorul: Se verifică tehnicile de bază de reducere a accesului la storage și gândirea la nivel de design. Candidații buni observă și problema buclei nelimitate.

73 Junior

Ce câștigi, ca gaz, înlocuind mesajele text de eroare cu custom errors? Cum ordonezi condițiile dintr-un require cu && ca să economisești gaz?

SOLIDITY
require(isWhitelisted(msg.sender) && amount > 0, "Not allowed or zero amount");

Răspuns scurt: Custom errors scot textul din bytecode (deploy mai ieftin) și produc date de revert de 4 octeți plus parametri. Cu &&, a doua condiție nu se evaluează dacă prima e falsă, deci pui întâi amount > 0, apoi verificarea care citește storage.

Mesajele text ocupă bytecode: fiecare string distinct se salvează în cod, iar costul de deploy crește cu fiecare octet. La revert, datele includ selectorul Error(string), offset, lungime și textul, deci se copiază mai mulți octeți. O eroare custom fără parametri înseamnă doar 4 octeți. Diferența la un singur revert e mică, dar în bytecode, pentru zeci de verificări, se adună și ajută și la limita de 24 KB.

Evaluarea scurtcircuitată: a && b nu evaluează b dacă a e fals; a || b nu evaluează b dacă a e adevărat. Dacă isWhitelisted citește un mapping cold (2100 de gaz), iar amount > 0 e o comparație pe stivă, ordinea contează pentru apelurile care eșuează.

Rescriere:

SOLIDITY
error ZeroAmount();
error NotWhitelisted(address account);

function buy(uint256 amount) external {
    if (amount == 0) revert ZeroAmount();
    if (!isWhitelisted(msg.sender)) revert NotWhitelisted(msg.sender);
    // ...
}

Separarea condițiilor are un beneficiu mai mare decât gazul: utilizatorul și testele știu exact ce regulă a eșuat. Un mesaj „Not allowed or zero amount” obligă la ghicit.

Reguli generale:

  • condițiile cele mai ieftine și cele care eșuează cel mai des le pui primele;
  • nu sacrifici claritatea pentru câțiva gaz în cod rar apelat;
  • verificările validării de input le faci înainte de orice citire din storage.

Ce urmărește intervievatorul: Se verifică două optimizări simple și sigure. Candidații buni menționează și beneficiul de claritate al erorilor separate.

Eroarea, în practică:reverted with custom error '...'

74 Mid

Mai are sens să scrii unchecked { ++i; } în bucle cu Solidity 0.8.22 sau mai nou? Când rămâne util unchecked?

SOLIDITY
for (uint256 i; i < n; ) {
    // ...
    unchecked { ++i; }
}

Răspuns scurt: Din 0.8.22, compilatorul omite automat verificarea de overflow pentru incrementul unui contor în bucle simple de forma for (uint i; i < n; ++i), deci tiparul manual nu mai aduce câștig acolo. unchecked rămâne util pentru alte operații despre care demonstrezi că nu pot depăși.

Înainte de 0.8.22, fiecare ++i dintr-o buclă includea o verificare de overflow, deși i < n o face imposibilă. Tiparul cu increment în unchecked la finalul corpului economisea câteva zeci de gaz pe iterație și apărea peste tot în codul optimizat.

Versiunea 0.8.22 a introdus o optimizare: dacă bucla are forma standard, cu comparație < sau <= între contor și o valoare, iar contorul e incrementat cu ++i sau i++ în expresia buclei și nu e modificat în corp, verificarea e omisă automat. Codul clar devine la fel de ieftin:

SOLIDITY
for (uint256 i; i < n; ++i) {
    // ...
}

Unde rămâne util unchecked:

  • scăderi după o verificare explicită: if (bal < amount) revert(); unchecked { balances[u] = bal - amount; }. Implementarea ERC-20 din OpenZeppelin face asta;
  • contoare care nu pot depăși realist (totalSupply limitat de altă regulă, nonce-uri);
  • aritmetică intenționat modulară.

Regula de siguranță: fiecare bloc unchecked are un comentariu care spune de ce operația nu poate depăși, iar testele (inclusiv fuzzing) acoperă valorile limită. Un audit va verifica fiecare bloc unchecked în parte.

Iar dacă proiectul folosește o versiune mai veche de 0.8.22, tiparul manual e încă relevant; versiunea compilatorului din foundry.toml sau hardhat.config decide.

Ce urmărește intervievatorul: Se verifică dacă urmărești evoluția compilatorului, nu doar sfaturile vechi de optimizare. Mulți candidați repetă tiparul fără să știe că nu mai e necesar.

75 Mid

Un airdrop are 100.000 de beneficiari, identificați prin indice. Cum ții evidența celor care au revendicat fără să plătești un slot de storage pentru fiecare?

Răspuns scurt: Folosești un bitmap: un mapping(uint256 => uint256), unde fiecare uint256 ține 256 de flag-uri. Indicele i se află în cuvântul i >> 8, la bitul i & 0xff. Un singur slot acoperă 256 de beneficiari, iar OpenZeppelin oferă BitMaps.BitMap gata făcut.

Un mapping(address => bool) folosește câte un slot de 32 de octeți pentru fiecare utilizator, deci fiecare prim claim plătește o scriere într-un slot gol, 20000 de gaz plus accesul cold. Un bitmap pune 256 de valori booleene într-un slot. Primul beneficiar dintr-un grup de 256 plătește scrierea în slotul gol, ceilalți doar modificarea unui slot nenul, mult mai ieftină.

SOLIDITY
mapping(uint256 => uint256) private claimedBitMap;

function isClaimed(uint256 index) public view returns (bool) {
    uint256 word = claimedBitMap[index >> 8];
    uint256 mask = 1 << (index & 0xff);
    return word & mask != 0;
}

function _setClaimed(uint256 index) private {
    claimedBitMap[index >> 8] |= 1 << (index & 0xff);
}

function claim(uint256 index, address account, uint256 amount, bytes32[] calldata proof) external {
    if (isClaimed(index)) revert AlreadyClaimed();
    bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(index, account, amount))));
    if (!MerkleProof.verify(proof, merkleRoot, leaf)) revert InvalidProof();
    _setClaimed(index);
    token.safeTransfer(account, amount);
}

index >> 8 e împărțirea la 256, iar index & 0xff e restul. Același tipar e folosit de distribuitorul Merkle al Uniswap.

Cu OpenZeppelin: using BitMaps for BitMaps.BitMap; BitMaps.BitMap private claimed; apoi claimed.get(i) și claimed.set(i).

Condiții: identificatorii trebuie să fie indici consecutivi (nu adrese), iar indicele trebuie legat criptografic de beneficiar (aici prin frunza Merkle), altfel cineva ar putea marca indicele altcuiva. Hash-ul dublu al frunzei previne confuzia dintre frunze și noduri interne.

Ce urmărește intervievatorul: Se verifică o tehnică de gaz cu impact mare la scară. Candidații buni observă și legătura obligatorie dintre indice și beneficiar.

76 Mid

De ce ReentrancyGuard din OpenZeppelin folosește valorile 1 și 2 pentru lacăt, nu 0 și 1? Ce s-a schimbat la refund-urile de gaz în upgrade-ul London?

Răspuns scurt: Din 0 în nenul, un SSTORE costă 20000 de gaz, din nenul în nenul 2900. Cu 1 și 2, slotul nu ajunge la zero, deci plătești varianta ieftină. Din London (EIP-3529), refund-ul de golire e 4800 și plafonat la o cincime din gazul tranzacției.

Costul unui SSTORE depinde de valoarea inițială a slotului în tranzacție și de cea nouă. Un lacăt clasic ar face:

  • intrare: 0 → 1, scriere într-un slot gol, 20000 de gaz;
  • ieșire: 1 → 0, cu refund.

Înainte de London, refund-ul acoperea o parte mare, dar era plafonat la jumătate din gazul tranzacției. După EIP-3529, refund-ul pentru golire a scăzut la 4800 și plafonul la o cincime. Un lacăt 0/1 ar costa deci mult mai mult decât pare.

Cu 1 (NOT_ENTERED) și 2 (ENTERED), slotul pleacă din 1 după deploy:

  • intrare: 1 → 2, modificare nenul-nenul;
  • ieșire: 2 → 1, revenire la valoarea de la începutul tranzacției, pentru care regulile EIP-2200 dau un refund care anulează aproape tot costul scrierii; costul net rămâne în principal accesul cold la slot.
SOLIDITY
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status = NOT_ENTERED;

Consecințe practice ale EIP-3529:

  • „gas tokens” (contracte care stocau date când gazul era ieftin și le ștergeau când era scump, ca să încaseze refund-ul) nu mai sunt profitabile; și refund-ul pentru SELFDESTRUCT a fost eliminat;
  • ștergerea datelor (delete) rămâne bună pentru igienă și aduce un refund mic, dar nu mai e o strategie de optimizare;
  • pentru flag-uri care se schimbă des, păstrează slotul nenul (de exemplu 1 și 2 în loc de 0 și 1).

Pe rețelele cu Cancun, lacătele pot folosi transient storage, care e mai ieftin decât ambele variante și se golește singur.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de cost pentru SSTORE dincolo de cifrele de bază. Explicația lui 1/2 în loc de 0/1 arată dacă ai citit cod de bibliotecă cu atenție.

Eroarea, în practică:ReentrancyGuardReentrantCall

77 Senior

Ce înseamnă setarea optimizer_runs din foundry.toml și cum o alegi? Ce aduce pipeline-ul via-IR și ce dezavantaje are?

[profile.default]
optimizer = true
optimizer_runs = 200
via_ir = false

Răspuns scurt: optimizer_runs estimează de câte ori rulează codul: valori mici dau bytecode mic, valori mari dau apeluri ieftine. Via-IR compilează prin Yul, optimizează mai agresiv și evită des „stack too deep”, dar compilează mai lent.

Optimizatorul are de ales între cod scurt și cod rapid. runs nu e un număr de treceri, ci o estimare a numărului de execuții pentru fiecare opcode pe durata de viață a contractului:

  • runs = 1: optimizează pentru deploy; potrivit pentru contracte publicate des și apelate rar (de exemplu instanțe create de un factory) sau pentru contracte aproape de limita de 24 KB;
  • runs = 200: valoarea implicită, un compromis;
  • runs mari (10.000 sau mai mult): pentru contracte apelate foarte des, precum un router sau un token principal, unde fiecare gaz economisit pe apel contează.

Alegerea se face măsurând: compilezi cu valori diferite și compari forge snapshot și forge build --sizes.

Via-IR (via_ir = true sau --via-ir): sursa trece întâi prin reprezentarea intermediară Yul, iar optimizatorul lucrează pe ea. Avantaje:

  • optimizări între funcții, mai eficiente decât pipeline-ul clasic;
  • mută variabile din stivă în memory când e nevoie, deci elimină multe erori „stack too deep”;
  • unele facilități au apărut întâi doar în via-IR (de exemplu require cu custom error în 0.8.26).

Dezavantaje:

  • compilare mult mai lentă pe proiecte mari;
  • acoperirea testelor (forge coverage) e mai greu de corelat cu sursa;
  • comportament diferit în cazuri limită (ordinea de evaluare a unor expresii poate diferi), deci schimbarea pipeline-ului cere rularea tuturor testelor.

Pentru verificarea pe explorer trebuie publicate exact aceleași setări: versiune, runs, via_ir, versiunea EVM. Altfel bytecode-ul nu se potrivește.

Ce urmărește intervievatorul: Se verifică înțelegerea setărilor de compilare care afectează costurile și verificarea. Candidații confundă des runs cu numărul de treceri ale optimizatorului.

Eroarea, în practică:Stack too deep

78 Senior

La deploy primești eroarea că bytecode-ul depășește limita de mărime. Care e limita și ce opțiuni ai, în ordinea în care le-ai încerca?

Răspuns scurt: Limita e 24.576 de octeți de cod runtime (EIP-170), iar initcode-ul e limitat la 49.152 (EIP-3860). Încerci: runs mic, custom errors, modifiers mutați în funcții interne, biblioteci externe, apoi împărțirea în contracte.

Limita a fost introdusă în 2016 (Spurious Dragon) ca protecție împotriva atacurilor de tip DoS asupra nodurilor. Afli mărimea fiecărui contract cu forge build --sizes; în Hardhat există pluginul hardhat-contract-sizer.

Opțiunile, de la cea mai ieftină la cea mai invazivă:

  • optimizator activ cu runs mic; uneori un pas de la 200 la 1 rezolvă problema;
  • custom errors în locul mesajelor text, care ocupă mult;
  • modifiers mari transformați în apeluri către funcții interne (_checkOwner()), pentru că un modifier se copiază la fiecare folosire;
  • eliminarea codului mort și a funcțiilor de vizualizare care pot fi calculate off-chain sau mutate într-un contract separat de tip „lens”, doar pentru citire;
  • biblioteci cu funcții external, publicate separat și apelate prin DELEGATECALL;
  • via-IR, care uneori produce cod mai mic;
  • împărțirea logicii în mai multe contracte cu responsabilități clare (de exemplu un contract pentru logica de lichidare și unul pentru depozite), care comunică prin interfețe.

Modelul Diamond (EIP-2535) împarte un contract în „fațete” în spatele aceluiași proxy și ocolește limita, dar aduce complexitate mare de audit și de gestionare a storage-ului. Îl propui doar dacă celelalte variante nu ajung și echipa îl cunoaște.

Contractele de test și scripturile nu sunt afectate de limită în Foundry, iar pe rețeaua locală poți dezactiva limita (code_size_limit sau allowUnlimitedContractSize în Hardhat), dar asta doar ascunde problema până la deploy-ul real.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte mari și capacitatea de a prioritiza soluții. Greșeala tipică e să sari direct la o arhitectură complexă când o setare de compilator ar fi fost suficientă.

Securitate: unde e vulnerabilitatea

Exersează capitolul cu exerciții reale: Curs Solidity online →
79 Junior

Unde e vulnerabilitatea în contractul de mai jos?

SOLIDITY
contract Treasury {
    address public owner;
    constructor() { owner = msg.sender; }

    function setOwner(address newOwner) external {
        owner = newOwner;
    }

    function withdrawAll() external {
        require(msg.sender == owner, "not owner");
        payable(owner).transfer(address(this).balance);
    }
}

Răspuns scurt: setOwner nu are control al accesului: oricine își setează propria adresă ca owner și apoi apelează withdrawAll. Repari cu onlyOwner pe setOwner, ideal cu Ownable2Step din OpenZeppelin, care cere și acceptarea de către noul proprietar.

Atacul are doi pași, ambii accesibili oricui: setOwner(attacker), apoi withdrawAll(). Verificarea din withdrawAll e corectă, dar inutilă, pentru că proprietatea însăși poate fi schimbată fără verificare. E clasa de bug-uri cea mai simplă și, din experiența auditurilor publice, una dintre cele mai frecvente: o funcție de administrare rămasă fără modifier.

Varianta reparată cu OpenZeppelin 5:

SOLIDITY
import {Ownable, Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";

contract Treasury is Ownable2Step {
    constructor(address owner_) Ownable(owner_) {}

    function withdrawAll(address payable to) external onlyOwner {
        (bool ok, ) = to.call{value: address(this).balance}("");
        if (!ok) revert TransferFailed();
    }
}

Ownable2Step înlocuiește transferOwnership cu doi pași: proprietarul propune, iar noul proprietar apelează acceptOwnership. O adresă scrisă greșit nu mai poate prelua sau bloca contractul.

Cum găsești acest tip de bug la review:

  • listezi toate funcțiile external și public care scriu în stare și notezi pentru fiecare cine are voie să o apeleze;
  • verifici funcțiile initialize, care sunt tot funcții de administrare;
  • cauți funcții public care ar fi trebuit să fie internal (un _mint declarat public din greșeală);
  • scrii un test pentru fiecare funcție protejată, care verifică revert-ul pentru un cont oarecare.

Slither semnalează automat multe dintre aceste cazuri.

Ce urmărește intervievatorul: Se verifică dacă citești contractul ca un atacator, căutând drumul cel mai simplu. Candidații se uită des doar la funcția care trimite bani și ignoră cea care schimbă proprietarul.

80 Junior

E vulnerabilă funcția de mai jos în Solidity 0.8? Dar în 0.7? Ce ai schimba?

SOLIDITY
function withdraw(uint256 amount) external {
    require(balances[msg.sender] - amount >= 0, "fonduri insuficiente");
    balances[msg.sender] -= amount;
    (bool ok, ) = msg.sender.call{value: amount}("");
    require(ok, "transfer esuat");
}

Răspuns scurt: În 0.8 nu e exploatabilă: dacă amount depășește soldul, scăderea dă revert cu Panic(0x11). Dar require e inutil, pentru că un uint e mereu >= 0, iar mesajul nu apare niciodată. În 0.7, scăderea ar fi făcut wrap-around, deci oricine ar fi retras orice sumă.

Condiția x - y >= 0 cu uint256 e adevărată mereu, prin definiție. Compilatorul chiar dă un warning pentru o comparație tautologică. Intenția a fost „soldul e suficient”, dar expresia nu verifică asta.

În 0.8, protecția vine din altă parte: scăderea balances[msg.sender] - amount din condiție dă revert dacă rezultatul ar fi negativ, așa că funcția e sigură din întâmplare. Utilizatorul primește însă o eroare Panic(0x11) în loc de mesajul intenționat, iar oricine citește codul e indus în eroare. Dacă cineva mută scăderea într-un bloc unchecked pentru gaz, funcția devine exploatabilă.

În 0.7 sau mai vechi, fără SafeMath, scăderea făcea wrap-around: un utilizator cu sold 0 care cere 1 ether ar fi trecut verificarea, iar a doua scădere ar fi setat soldul la o valoare uriașă. Atacuri reale pe tokeni au exploatat exact acest tip de underflow.

Varianta corectă:

SOLIDITY
error InsufficientBalance(uint256 available, uint256 requested);

function withdraw(uint256 amount) external {
    uint256 bal = balances[msg.sender];
    if (bal < amount) revert InsufficientBalance(bal, amount);
    unchecked { balances[msg.sender] = bal - amount; } // sigur după verificare
    (bool ok, ) = msg.sender.call{value: amount}("");
    if (!ok) revert TransferFailed();
}

Ordinea e deja corectă (starea se actualizează înainte de call), deci reentrancy-ul nu poate retrage de două ori aceeași sumă. Rămâne o recomandare: nonReentrant dacă există alte funcții care citesc balances în timpul apelului extern.

Ce urmărește intervievatorul: Se verifică înțelegerea fină a aritmeticii fără semn și a protecției din 0.8. Candidații buni observă că funcția e sigură doar din întâmplare.

Eroarea, în practică:panic code 0x11 (underflow / overflow)

81 Junior

O licitație se încheie la endTime. E sigur să folosești block.timestamp? Ce poate controla cel care produce blocul?

SOLIDITY
function bid() external payable {
    require(block.timestamp < endTime, "terminata");
    // ...
}

Răspuns scurt: În 0.8 nu e exploatabilă: scăderea dă revert cu Panic(0x11) dacă suma depășește soldul. Dar require e inutil, un uint e mereu >= 0. În 0.7, scăderea făcea wrap-around și oricine retrăgea orice sumă.

block.timestamp e momentul blocului în secunde Unix, ales de cel care produce blocul în limitele regulilor rețelei. Pe Ethereum, după trecerea la Proof of Stake, timestamp-ul unui bloc e determinat de slotul în care e propus, deci propunătorul nu îl poate muta. Înainte de The Merge, minerii aveau o marjă de câteva secunde. Pe alte rețele și pe L2-uri regulile diferă: unele rețele permit o marjă mai mare sau au blocuri foarte dese, deci verifici documentația.

Ce poate face, în continuare, un propunător sau un bot:

  • să includă sau să excludă tranzacții în blocul de la limită: o ofertă trimisă cu câteva secunde înainte de termen poate fi lăsată pe dinafară sau depășită de o ofertă plasată înaintea ei în același bloc;
  • să aleagă ordinea tranzacțiilor din bloc.

Recomandări:

  • pentru termene, block.timestamp e alegerea standard; block.number e mai puțin potrivit, pentru că timpul dintre blocuri diferă între rețele;
  • folosești < și >= consecvent, ca un moment să nu aparțină ambelor stări;
  • pentru licitații, extinzi termenul dacă apare o ofertă în ultimele minute (anti-sniping), ca să reduci avantajul celui care ordonează tranzacțiile;
  • nu calculezi nimic aleatoriu din timestamp, pentru că e cunoscut dinainte.
SOLIDITY
if (block.timestamp >= endTime) revert AuctionEnded();
if (endTime - block.timestamp < 10 minutes) endTime += 10 minutes;

Ce urmărește intervievatorul: Se verifică înțelegerea realistă a riscului de timp, nici exagerată, nici ignorată. Mulți candidați citează reguli de dinainte de The Merge ca fiind actuale.

82 Junior

Ce unelte de analiză automată rulezi pe un contract înainte de review-ul manual? Ce tip de probleme găsește fiecare și ce nu pot găsi?

Răspuns scurt: Slither (analiză statică, rapidă, multe detectoare), Aderyn (analiză statică, raport în Markdown), Mythril (execuție simbolică), Solhint (stil și bune practici), plus fuzzere precum Echidna, Medusa sau cel din Foundry. Ele găsesc tipare cunoscute, dar nu înțeleg logica de business, deci nu înlocuiesc review-ul manual.

Uneltele, pe categorii:

  • Slither (Trail of Bits): analizează codul compilat și raportează reentrancy, variabile neinițializate, tx.origin, apeluri cu rezultat ignorat, encodePacked cu tipuri dinamice, funcții care ar putea fi external. Se rulează cu slither . în rădăcina unui proiect Foundry sau Hardhat. Are și „printers”, utile pentru a înțelege un cod nou (graf de apeluri, moștenire, cine scrie fiecare variabilă);
  • Aderyn (Cyfrin): analiză statică scrisă în Rust, cu raport ușor de citit, util ca a doua opinie;
  • Mythril: execuție simbolică, explorează căi prin cod și caută stări periculoase; mai lent, util pe contracte mici;
  • Solhint: linter pentru stil și convenții; forge fmt pentru formatare;
  • fuzzere și testare de invarianți: Foundry, Echidna, Medusa; găsesc cazuri limită pe baza proprietăților pe care le scrii tu;
  • verificare formală (Certora, Halmos): demonstrează proprietăți pentru toate intrările posibile, la cost mare de configurare.

Ce nu pot găsi: o formulă de recompensă greșită, un comision care poate fi ocolit, o ordine de operații care permite manipularea prețului, o presupunere greșită despre un protocol extern. Aceste probleme cer înțelegerea intenției.

Mod de lucru sănătos: unelte rulate automat în CI, fiecare constatare fie reparată, fie marcată explicit ca fals pozitiv cu justificare, apoi review manual concentrat pe logica de business. Un raport curat de la Slither nu înseamnă un contract sigur.

Ce urmărește intervievatorul: Se verifică dacă știi ecosistemul de unelte și limitele lui. Greșeala tipică e prezentarea unui raport automat curat drept dovadă de securitate.

83 Mid

Unde sunt vulnerabilitățile în verificarea de semnătură de mai jos? signer e setat de administrator printr-o funcție separată.

SOLIDITY
address public signer;

function claim(uint256 amount, uint8 v, bytes32 r, bytes32 s) external {
    bytes32 h = keccak256(abi.encodePacked(msg.sender, amount));
    require(ecrecover(h, v, r, s) == signer, "semnatura invalida");
    token.transfer(msg.sender, amount);
}

Răspuns scurt: Slither și Aderyn (analiză statică), Mythril (execuție simbolică), Solhint (stil), plus fuzzere ca Echidna, Medusa sau Foundry. Găsesc tipare cunoscute, dar nu înțeleg logica de business, deci nu înlocuiesc review-ul manual.

Problemele, în ordinea gravității:

  • address(0): ecrecover nu dă revert pentru date invalide, ci întoarce zero. Până când administratorul setează signer, sau dacă îl resetează la zero, oricine trimite v, r, s aleatorii poate revendica orice sumă;
  • reutilizare: nimic nu marchează semnătura ca folosită, deci același utilizator o trimite de câte ori vrea;
  • lipsa domeniului: mesajul nu conține adresa contractului și nici block.chainid, deci o semnătură pentru alt contract sau altă rețea, cu aceleași câmpuri, e acceptată;
  • lipsa prefixului: portofelele semnează prin personal_sign cu prefixul EIP-191 ("\x19Ethereum Signed Message:\n32"); fără el, semnătura obținută normal nu va trece, iar echipa ajunge să semneze hash-uri brute, ceea ce e periculos;
  • maleabilitate: pentru fiecare semnătură validă există una echivalentă (cu s din jumătatea superioară a curbei); dacă unicitatea se bazează pe hash-ul semnăturii, poate fi ocolită;
  • token.transfer fără verificarea rezultatului.

Varianta corectă:

SOLIDITY
using SafeERC20 for IERC20;
bytes32 constant CLAIM_TYPEHASH = keccak256("Claim(address account,uint256 amount,uint256 nonce)");
mapping(address => uint256) public nonces;

function claim(uint256 amount, bytes calldata sig) external {
    bytes32 structHash = keccak256(abi.encode(CLAIM_TYPEHASH, msg.sender, amount, nonces[msg.sender]++));
    address rec = ECDSA.recover(_hashTypedDataV4(structHash), sig); // contract EIP712
    if (rec != signer) revert InvalidSignature();
    token.safeTransfer(msg.sender, amount);
}

ECDSA.recover respinge semnăturile maleabile și dă revert pentru zero, iar _hashTypedDataV4 din EIP712 include automat chainId-ul și adresa contractului.

Ce urmărește intervievatorul: Se verifică experiența practică cu ecrecover, unde fiecare detaliu e o vulnerabilitate posibilă. Cazul address(0) e cel pe care îl ratează cei mai mulți.

84 Mid

Ce verificări lipsesc în funcția care citește prețul de la Chainlink?

SOLIDITY
function getPrice() public view returns (uint256) {
    (, int256 answer, , , ) = priceFeed.latestRoundData();
    return uint256(answer) * 1e10;
}

Răspuns scurt: Lipsesc verificarea că prețul e pozitiv, că e recent (updatedAt comparat cu heartbeat-ul feed-ului), citirea decimals() în loc de presupunerea a 8 zecimale și, pe L2-uri, verificarea feed-ului de stare al sequencer-ului. Fără ele, un preț vechi sau zero poate permite lichidări sau împrumuturi greșite.

latestRoundData întoarce (roundId, answer, startedAt, updatedAt, answeredInRound). Contractul folosește doar answer, fără să verifice nimic.

Ce poate merge prost:

  • answer negativ sau zero: conversia uint256(answer) din negativ dă un număr uriaș, iar zero face colateralul fără valoare;
  • preț vechi: feed-ul se actualizează la o deviație de preț sau la un interval maxim (heartbeat), diferit pentru fiecare feed. Dacă actualizările se opresc, contractul folosește un preț care nu mai e real;
  • zecimale: multe feed-uri în USD au 8 zecimale, dar nu toate; codul fix * 1e10 presupune 8;
  • pe L2-uri, când sequencer-ul e oprit, prețurile rămân înghețate, iar la repornire utilizatorii nu au avut ocazia să-și ajusteze pozițiile.

Varianta robustă:

SOLIDITY
uint256 public constant MAX_DELAY = 1 hours; // după heartbeat-ul feed-ului ales

function getPrice() public view returns (uint256) {
    (, int256 answer, , uint256 updatedAt, ) = priceFeed.latestRoundData();
    if (answer <= 0) revert InvalidPrice();
    if (updatedAt == 0 || block.timestamp - updatedAt > MAX_DELAY) revert StalePrice();
    uint8 dec = priceFeed.decimals();
    return uint256(answer) * 10 ** (18 - dec); // presupune dec <= 18
}

Pe L2 adaugi verificarea Sequencer Uptime Feed: dacă sequencer-ul e oprit sau a repornit de curând, refuzi operațiile sensibile pentru o perioadă de grație.

Decizii de design: la un preț invalid, protocolul dă revert (sigur, dar blochează operațiile) sau folosește un oracol de rezervă. Pentru lichidări, o blocare lungă e și ea un risc, deci decizia se documentează.

Ce urmărește intervievatorul: Se verifică integrarea corectă a unui oracol, foarte frecventă în DeFi. Lipsa verificării de prospețime apare des în rapoartele de audit.

85 Mid

Contractul de mai jos e un router de depuneri. Utilizatorii îi dau aprobare nelimitată pentru USDC. Unde e vulnerabilitatea?

SOLIDITY
function depositFor(address from, uint256 amount) external {
    usdc.transferFrom(from, address(this), amount);
    balances[msg.sender] += amount;
}

Răspuns scurt: from e un parametru liber: oricine poate transfera tokenii oricărui utilizator care a aprobat routerul și primește creditul în propriul cont. Atacatorul golește pe rând toate portofelele cu aprobare. Sursa trebuie să fie msg.sender.

Aprobarea ERC-20 e dată contractului, nu unei acțiuni anume. Când contractul face transferFrom(from, ...), tokenul verifică doar că msg.sender (routerul) are allowance de la from. Nu știe și nu îi pasă cine a cerut operația routerului.

Pașii atacului:

  • atacatorul caută în events Approval adresele care au aprobat routerul;
  • apelează depositFor(victima, soldul victimei);
  • tokenii victimei ajung în router, iar balances[atacator] crește;
  • atacatorul retrage.

Aprobările nelimitate, comune pentru comoditate, fac paguba maximă: tot soldul curent și viitor al victimei e expus.

Repararea:

SOLIDITY
using SafeERC20 for IERC20;

function deposit(uint256 amount) external {
    usdc.safeTransferFrom(msg.sender, address(this), amount);
    balances[msg.sender] += amount;
}

Dacă produsul chiar are nevoie de „depune în numele altcuiva”, banii vin tot de la msg.sender, iar creditul merge la beneficiar:

SOLIDITY
function depositFor(address beneficiary, uint256 amount) external {
    usdc.safeTransferFrom(msg.sender, address(this), amount);
    balances[beneficiary] += amount;
}

Același tipar apare la contracte care primesc calldata arbitrară de executat (target.call(data)) cu aprobări active: un atacator construiește un apel transferFrom către token. Regula: un contract care deține aprobări nu face niciodată transferFrom dintr-o sursă aleasă de apelant și nu execută apeluri arbitrare către tokeni.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de aprobări și a cui e autoritatea în transferFrom. Bug-ul a dus la pierderi reale în protocoale publicate.

86 Senior

Un vault calculează câte shares ard la o retragere. Ce e greșit în rotunjire și cum poate fi exploatat?

SOLIDITY
function withdraw(uint256 assets) external {
    uint256 shares = assets * totalSupply() / totalAssets();
    _burn(msg.sender, shares);
    asset.safeTransfer(msg.sender, assets);
}

Răspuns scurt: Împărțirea rotunjește în jos, deci utilizatorul arde mai puține shares decât valorează activele primite. La sume mici, shares poate fi chiar 0: retrageri repetate de câteva unități scot active fără să ardă nimic. La retragere, numărul de shares se rotunjește în sus, în favoarea vault-ului.

Principiul general: rotunjirea se face întotdeauna în favoarea protocolului, ca nicio secvență de operații să nu poată scoate mai mult decât s-a depus. Standardul ERC-4626 îl spune explicit: previewDeposit și previewRedeem rotunjesc în jos (utilizatorul primește mai puțin), previewMint și previewWithdraw rotunjesc în sus (utilizatorul dă mai mult).

În cod, pentru withdraw(assets), utilizatorul cere un număr exact de active, deci numărul de shares arse trebuie rotunjit în sus. Exploatarea: când un share valorează mai mult de o unitate de activ, de exemplu după acumularea randamentului, o retragere de assets mai mic decât valoarea unui share dă shares = 0. Un atacator repetă retrageri mici. Fiecare costă gaz, deci pe mainnet atacul e de obicei neprofitabil, dar pe un L2 ieftin sau cu un activ cu puține zecimale și valoare mare, poate fi. Chiar fără exploatare directă, fiecare retragere mută o mică valoare de la cei rămași la cel care iese.

Varianta corectă:

SOLIDITY
using Math for uint256;

function withdraw(uint256 assets) external {
    uint256 shares = assets.mulDiv(totalSupply() + 1, totalAssets() + 1, Math.Rounding.Ceil);
    if (shares == 0) revert ZeroShares();
    _burn(msg.sender, shares);
    asset.safeTransfer(msg.sender, assets);
}

+1 urmează modelul de virtual shares al OpenZeppelin și evită împărțirea la zero. Testul potrivit e unul de invariant: după orice secvență de depuneri și retrageri, totalAssets() acoperă valoarea tuturor shares.

Ce urmărește intervievatorul: Se verifică gândirea despre rotunjiri ca problemă de securitate. Un candidat senior trebuie să știe direcția corectă pentru fiecare operație.

87 Senior

Un DAO numără voturile după soldul curent de tokeni. Unde e vulnerabilitatea și cum o repari?

SOLIDITY
function vote(uint256 proposalId, bool support) external {
    uint256 weight = govToken.balanceOf(msg.sender);
    require(!voted[proposalId][msg.sender]);
    voted[proposalId][msg.sender] = true;
    if (support) proposals[proposalId].forVotes += weight;
    else proposals[proposalId].againstVotes += weight;
}

Răspuns scurt: Împărțirea rotunjește în jos, deci utilizatorul arde mai puține shares decât valorează activele primite; la sume mici, chiar 0. La retragere, numărul de shares arse se rotunjește în sus, în favoarea vault-ului.

Două atacuri:

  • flash loan: atacatorul împrumută o cantitate mare de tokeni de guvernanță, votează (sau propune și execută, dacă nu există întârzieri) și returnează împrumutul, totul într-o singură tranzacție. Beanstalk a pierdut fonduri în 2022 printr-un atac de acest tip asupra guvernanței;
  • vot dublu: Alice votează cu 100 de tokeni, îi transferă lui Bob, iar Bob votează cu aceiași 100. Marcajul voted e per adresă, nu per token.

Soluția: puterea de vot se citește la un moment din trecut, fixat la crearea propunerii. ERC20Votes din OpenZeppelin păstrează istoricul („checkpoints”) puterii de vot a fiecărei adrese:

SOLIDITY
function vote(uint256 id, bool support) external {
    Proposal storage p = proposals[id];
    if (voted[id][msg.sender]) revert AlreadyVoted();
    uint256 weight = govToken.getPastVotes(msg.sender, p.snapshot);
    voted[id][msg.sender] = true;
    if (support) p.forVotes += weight; else p.againstVotes += weight;
}

p.snapshot e un moment anterior creării propunerii, deci tokenii primiți ulterior (prin împrumut sau transfer) nu mai contează.

Măsuri suplimentare, care vin gata făcute în Governor din OpenZeppelin:

  • întârziere între propunere și începerea votului (voting delay);
  • prag minim de tokeni pentru a propune și cvorum;
  • timelock între aprobare și execuție, ca utilizatorii să poată reacționa la o propunere ostilă.

Detaliu de implementare: în ERC20Votes, utilizatorii trebuie să își delege puterea de vot (chiar și lor înșiși) ca ea să fie numărată; interfața trebuie să explice asta.

Ce urmărește intervievatorul: Se verifică înțelegerea atacurilor economice asupra guvernanței. Candidații se opresc des la votul dublu și uită flash loan-urile.

88 Senior

Unde e vulnerabilitatea? Contractul oferă un multicall pentru a grupa mai multe operații într-o tranzacție.

SOLIDITY
function multicall(bytes[] calldata calls) external payable {
    for (uint256 i; i < calls.length; i++) {
        (bool ok, ) = address(this).delegatecall(calls[i]);
        require(ok);
    }
}

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

Răspuns scurt: delegatecall păstrează msg.value al apelului original, deci fiecare apel deposit din multicall vede aceeași valoare. Cu 1 ether și 10 apeluri deposit, atacatorul e creditat cu 10 ether. msg.value nu trebuie citit în cod care poate rula de mai multe ori în aceeași tranzacție.

Un delegatecall către propriul contract execută funcția în același context: msg.sender și msg.value rămân cele ale tranzacției. Multicall-ul face asta într-o buclă, deci fiecare sub-apel crede că a primit valoarea întreagă, deși ether-ul a intrat o singură dată.

Atacul:

SOLIDITY
bytes[] memory calls = new bytes[](10);
for (uint256 i; i < 10; i++) calls[i] = abi.encodeCall(Vault.deposit, ());
vault.multicall{value: 1 ether}(calls);
vault.withdraw(10 ether); // retrage ether-ul altor utilizatori

Aceeași problemă apare și fără multicall, ori de câte ori msg.value e folosit într-o buclă sau într-o funcție internă apelată de mai multe ori. Bug-uri de acest tip au fost raportate în protocoale reale, unele cu sume foarte mari expuse.

Reparații posibile:

  • multicall-ul nu e payable. Multicall din OpenZeppelin nu este payable tocmai din acest motiv;
  • dacă e nevoie de ether, funcțiile nu citesc msg.value direct, ci consumă dintr-un buget urmărit explicit:
SOLIDITY
uint256 private _ethBudget; // setat în multicall, scăzut la fiecare utilizare

function deposit(uint256 amount) external payable {
    if (amount > _ethBudget) revert NotEnoughEth();
    _ethBudget -= amount;
    balances[msg.sender] += amount;
}
  • sau ether-ul se convertește întâi o singură dată în WETH, iar operațiile lucrează cu tokenul.

Testul de securitate potrivit: un test care apelează multicall cu aceeași funcție payable de două ori și verifică soldul total față de ether-ul primit.

Ce urmărește intervievatorul: Se verifică înțelegerea contextului în delegatecall și combinarea tiparelor. E o vulnerabilitate de nivel senior, ușor de ratat la un review grăbit.

89 Senior

Un forwarder de meta-tranzacții execută apeluri în numele utilizatorilor și marchează nonce-ul ca folosit. Cum poate un relayer rău-intenționat să strice execuția și cum te aperi? Ce e un „return bomb”?

SOLIDITY
function execute(Request calldata req, bytes calldata sig) external {
    _verify(req, sig);
    nonces[req.from]++;
    (bool ok, ) = req.to.call{gas: req.gas}(abi.encodePacked(req.data, req.from));
    emit Executed(req.from, ok);
}

Răspuns scurt: delegatecall păstrează msg.value, deci fiecare deposit din multicall vede aceeași valoare: cu 1 ether și 10 apeluri, atacatorul e creditat cu 10. msg.value nu se citește în cod care poate rula de mai multe ori într-o tranzacție.

La un CALL, apelantul poate transmite cel mult 63/64 din gazul rămas. Dacă cere {gas: req.gas} și are mai puțin disponibil, sub-apelul primește mai puțin, fără eroare. Relayer-ul controlează gazul total al tranzacției, deci îl alege astfel încât apelul către req.to să rămână fără gaz, în timp ce forwarder-ul are destul pentru a termina. Rezultatul: nonce-ul e consumat, Executed(from, false) e emis, iar acțiunea utilizatorului (de exemplu o tranzacție cu termen limită) nu se mai poate executa cu aceeași semnătură.

Apărarea, folosită de ERC2771Forwarder din OpenZeppelin:

SOLIDITY
(bool ok, ) = req.to.call{gas: req.gas}(abi.encodePacked(req.data, req.from));
if (gasleft() < req.gas / 63) {
    // sub-apelul nu a primit tot gazul cerut: forțăm eșecul întregii tranzacții
    assembly { invalid() }
}

Dacă după apel a rămas mai puțin de 1/63 din gazul cerut, înseamnă că sub-apelul nu a primit req.gas, deci relayer-ul a trimis prea puțin. Tranzacția e anulată, nonce-ul rămâne nefolosit.

Return bomb: (bool ok, bytes memory ret) = target.call(...) copiază automat toate datele returnate în memory. Un contract ostil poate întoarce sute de kilobytes, iar costul memoriei, care crește pătratic, epuizează gazul apelantului chiar dacă sub-apelul avea o limită. Chiar și forma (bool ok, ) copiază datele în versiunile curente ale compilatorului. Soluția e un apel în assembly care nu copiază datele (call(g, to, v, in, insize, 0, 0)) sau care copiază cel mult un număr fix de octeți, cum face biblioteca ExcessivelySafeCall.

Ambele probleme apar în orice cod care apelează contracte nesigure cu gaz limitat: relayere, contracte de lichidare, sisteme de callback.

Ce urmărește intervievatorul: Se verifică stăpânirea mecanicii gazului la apeluri externe, un subiect de nivel auditor. Puțini candidați știu să explice de ce verificarea se face după apel.

Testare, unelte și situații practice

90 Junior

Scrie un test Foundry pentru un contract Piggy cu deposit() payable și balanceOf(address). Explică structura fișierului de test și convențiile de nume.

Răspuns scurt: Testul e un contract care moștenește Test din forge-std. setUp() rulează înaintea fiecărui test, funcțiile cu prefix test sunt teste, iar cele cu parametri sunt fuzz tests. Folosești vm.deal pentru ether, vm.prank pentru apelant și assertEq pentru verificări.

Fișierul stă de obicei în test/Piggy.t.sol:

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

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

contract PiggyTest is Test {
    Piggy piggy;
    address alice = makeAddr("alice");

    function setUp() public {
        piggy = new Piggy();
        vm.deal(alice, 10 ether);
    }

    function test_Deposit_UpdatesBalance() public {
        vm.prank(alice);
        piggy.deposit{value: 1 ether}();
        assertEq(piggy.balanceOf(alice), 1 ether);
        assertEq(address(piggy).balance, 1 ether);
    }

    function test_RevertWhen_DepositIsZero() public {
        vm.prank(alice);
        vm.expectRevert(Piggy.ZeroDeposit.selector);
        piggy.deposit{value: 0}();
    }

    function testFuzz_Deposit(uint96 amount) public {
        vm.assume(amount > 0);
        vm.deal(alice, amount);
        vm.prank(alice);
        piggy.deposit{value: amount}();
        assertEq(piggy.balanceOf(alice), amount);
    }
}

Convenții:

  • setUp rulează din nou înaintea fiecărui test, pe o stare curată, deci testele sunt independente;
  • numele descriu comportamentul: test_, test_RevertWhen_, testFuzz_;
  • makeAddr("alice") creează o adresă cu etichetă, care apare în trace-uri;
  • prefixul vechi testFail era folosit pentru teste care trebuie să eșueze; e depreciat, iar varianta corectă e vm.expectRevert, care verifică și motivul.

Rulare: forge test, forge test --match-test Deposit -vvv pentru un singur test, cu trace la eșec.

Ce urmărește intervievatorul: Se verifică dacă ai scris teste reale în Foundry. Candidații care nu verifică motivul revert-ului sau scriu teste dependente între ele sunt ușor de observat.

91 Junior

Cum testezi un contract de vesting care eliberează tokenii abia după 30 de zile, doar către beneficiar? Ce cheatcodes folosești?

Răspuns scurt: Muți timpul cu vm.warp, schimbi apelantul cu vm.prank sau vm.startPrank, dai solduri cu deal și verifici erorile cu vm.expectRevert. Testezi trei momente: înainte de termen (revert), exact la termen și după, plus un apelant greșit.

Cheatcodes sunt funcții speciale ale mediului de test Foundry, apelate prin vm:

  • vm.warp(t) setează block.timestamp; skip(s) din forge-std avansează cu s secunde;
  • vm.roll(n) setează block.number;
  • vm.prank(a) face ca următorul apel să aibă msg.sender = a; vm.startPrank(a) și vm.stopPrank() pentru mai multe apeluri;
  • vm.deal(a, x) setează soldul de ether; deal(address(token), a, x) din forge-std setează soldul unui ERC-20;
  • vm.expectEmit verifică un event; vm.expectRevert verifică o eroare.
SOLIDITY
function setUp() public {
    token = new MockToken();
    vesting = new Vesting(address(token), bob, block.timestamp + 30 days);
    deal(address(token), address(vesting), 1000e18);
}

function test_RevertWhen_ReleasedTooEarly() public {
    vm.warp(block.timestamp + 30 days - 1);
    vm.prank(bob);
    vm.expectRevert(Vesting.NotYet.selector);
    vesting.release();
}

function test_ReleaseAtCliff() public {
    vm.warp(vesting.unlockAt());
    vm.prank(bob);
    vesting.release();
    assertEq(token.balanceOf(bob), 1000e18);
}

function test_RevertWhen_NotBeneficiary() public {
    vm.warp(vesting.unlockAt());
    vm.prank(makeAddr("eve"));
    vm.expectRevert(Vesting.NotBeneficiary.selector);
    vesting.release();
}

Testul cu o secundă înainte de termen și cel exact la termen prind erorile < față de <=, cea mai frecventă greșeală în logica de timp.

În Hardhat, echivalentele sunt în @nomicfoundation/hardhat-network-helpers: time.increase, time.increaseTo, impersonateAccount, setBalance.

Ce urmărește intervievatorul: Se verifică fluența cu uneltele de test pentru timp și identitate. Candidații buni testează explicit valorile de la limită.

92 Junior

Un coleg vine din backend (Java sau JavaScript) și începe să scrie contracte. Ce i-ai explica întâi despre diferențele față de codul obișnuit?

Răspuns scurt: Aș începe cu patru idei: codul publicat nu se mai schimbă ușor, fiecare operație costă bani, toate datele sunt publice și oricine poate apela orice funcție, oricând, în orice ordine. Apoi aș arăta pe cod concret trei bug-uri tipice și cum le prind testele.

Structura pe care aș folosi-o: context, diferențe, exemple, practică.

Diferențele, explicate prin comparație cu ce știe deja:

  • imutabilitate: un bug în backend se repară cu un deploy; un contract publicat rămâne așa, sau se schimbă printr-un mecanism de upgrade care are propriile riscuri. De aceea testele și review-ul se fac înainte, nu după;
  • costul: fiecare citire și scriere din storage se plătește de utilizator, deci bucle peste liste nelimitate, structuri mari și logica de prezentare nu au ce căuta în contract;
  • mediu adversarial: într-un API ai autentificare și rate limiting; aici oricine apelează orice funcție external, cu orice argumente, inclusiv din alte contracte care reintră în al tău. Orice apel extern e cod străin;
  • date publice: private înseamnă doar „necitibil din alte contracte”; oricine vede storage-ul;
  • fără zecimale și fără excepții prinse automat: împărțirea e întreagă, iar un revert anulează toată tranzacția;
  • tranzacții atomice: fie se aplică toate schimbările, fie niciuna, ceea ce simplifică unele lucruri.

Exemple concrete pe care le-aș arăta: o funcție de administrare fără modifier, un withdraw care trimite ether înainte să actualizeze soldul, o împărțire înaintea înmulțirii. Le scriem împreună teste care le prind.

Apoi practică: îi dau un contract mic de scris cu Foundry, cu teste pentru cazurile limită și revert-uri, iar la review urmăresc gândirea, nu doar sintaxa. Îi recomand să citească implementări OpenZeppelin, ca exemplu de stil și de rigoare.

Ce urmărește intervievatorul: Se verifică dacă înțelegi diferențele fundamentale și le poți comunica structurat. Răspunsurile slabe se rezumă la sintaxă și ignoră mediul adversarial.

93 Mid

forge coverage raportează 100% acoperire pe linii pentru un contract. De ce asta nu înseamnă că e corect? Cum folosești totuși raportul?

Răspuns scurt: Testul e un contract care moștenește Test din forge-std. setUp() rulează înaintea fiecărui test, funcțiile cu prefix test sunt teste, cele cu parametri sunt fuzz tests. Folosești vm.deal, vm.prank și assertEq.

forge coverage (sau solidity-coverage în Hardhat) instrumentează codul și arată ce linii, instrucțiuni, ramuri și funcții au rulat în teste. Cu --report lcov generezi un raport vizualizabil în editor sau în HTML.

Ce nu măsoară:

  • calitatea aserțiunilor: o linie executată fără verificarea rezultatului apare acoperită;
  • combinațiile de stare: o funcție poate fi testată separat, dar bug-ul apare doar după o anumită secvență (depunere, randament, retragere parțială);
  • valorile limită: 0, 1, valoarea maximă, sume cu rest la împărțire;
  • interacțiunea cu contracte externe ostile: tokeni fără valoare returnată, receptori care dau revert sau reintră;
  • proprietățile economice: dacă un atacator poate scoate mai mult decât a depus.

Cum îl folosești:

  • cauți ramurile if și revert neatinse; de obicei înseamnă un caz de eroare netestat;
  • funcțiile de administrare neacoperite indică lipsa testelor de control al accesului;
  • îl rulezi în CI, ca o scădere a acoperirii să fie vizibilă la code review.

Ce adaugi peste acoperire: teste negative pentru fiecare regulă, fuzzing pentru calcule, teste de invarianți pentru proprietăți globale (suma soldurilor egală cu totalul), teste pe fork pentru integrări reale.

Detaliu practic: cu via-IR, acoperirea poate eșua sau poate fi imprecisă; forge coverage --ir-minimum e o soluție de compromis, cu o corelare mai slabă cu sursa.

Ce urmărește intervievatorul: Se verifică maturitatea în testare: diferența dintre a rula codul și a-l verifica. Răspunsul slab e „am 100%, deci e testat”.

94 Mid

Contractul tău citește prețul dintr-un oracol extern și soldul dintr-un token. Cum îl testezi izolat, fără să publici oracolul real? Când preferi un test pe fork?

Răspuns scurt: Fie folosești contracte mock simple (un MockERC20, un MockV3Aggregator cu preț setabil), fie suprascrii răspunsul unui apel cu vm.mockCall(adresa, calldata, rezultat). Testul pe fork îl folosești când contează comportamentul real al contractului extern: zecimale, taxe, particularități.

Mock-uri ca contracte: scrii o implementare minimală a interfeței, cu funcții de setare pentru test.

SOLIDITY
contract MockFeed {
    int256 public answer;
    uint256 public updatedAt;
    uint8 public constant decimals = 8;
    function set(int256 a, uint256 t) external { answer = a; updatedAt = t; }
    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (0, answer, 0, updatedAt, 0);
    }
}

Avantaj: controlezi exact scenariile, inclusiv cele greu de reprodus (preț negativ, preț vechi).

Mock prin cheatcode, fără contract nou:

SOLIDITY
vm.mockCall(
    address(feed),
    abi.encodeWithSelector(IFeed.latestRoundData.selector),
    abi.encode(uint80(0), int256(2000e8), uint256(0), block.timestamp, uint80(0))
);
vm.mockCallRevert(address(token), abi.encodeWithSelector(IERC20.transfer.selector), "");

vm.mockCall interceptează apelurile cu acel calldata către acea adresă, indiferent de codul de acolo. E rapid pentru un singur caz, dar testele cu multe mock-uri devin greu de citit.

Fork (forge test --fork-url $RPC_URL --fork-block-number N): testezi împotriva contractelor reale, la o stare fixată. Îl alegi când:

  • integrarea depinde de detalii reale: USDT care nu întoarce bool, tokeni cu taxă la transfer, zecimale diferite;
  • verifici un upgrade pe starea din producție;
  • reproduci un incident.

Dezavantaje: teste mai lente, dependență de un RPC; fixarea blocului face rezultatele reproductibile și permite cache-ul local. O suită bună combină: mock-uri pentru logică și cazuri de eroare, fork pentru integrare.

Ce urmărește intervievatorul: Se verifică dacă știi să izolezi dependențele și să alegi nivelul potrivit de test. Mulți candidați testează doar cu mock-uri și ratează particularitățile tokenilor reali.

95 Mid

Cum testezi că un contract de licitație rămâne funcțional când fostul ofertant de top e un contract care refuză să primească ether înapoi?

Răspuns scurt: Scrii în test un contract atacator cu receive() care dă revert, îl folosești ca ofertant, apoi verifici că o ofertă nouă de la alt utilizator reușește. Dacă licitația returnează banii prin push, testul eșuează și arată vulnerabilitatea DoS; cu pull, trece.

Multe vulnerabilități apar doar când contrapartea e un contract ostil, iar testele obișnuite folosesc doar adrese externe. Soluția e să scrii contractele ostile chiar în fișierul de test.

SOLIDITY
contract RejectingBidder {
    Auction auction;
    constructor(Auction a) { auction = a; }
    function bid() external payable { auction.bid{value: msg.value}(); }
    receive() external payable { revert("nu primesc"); }
}

contract AuctionTest is Test {
    Auction auction;
    address alice = makeAddr("alice");

    function setUp() public {
        auction = new Auction(block.timestamp + 1 days);
        vm.deal(alice, 10 ether);
    }

    function test_OutbidRejectingBidder() public {
        RejectingBidder evil = new RejectingBidder(auction);
        evil.bid{value: 1 ether}();

        vm.prank(alice);
        auction.bid{value: 2 ether}();          // trebuie să reușească

        assertEq(auction.highestBidder(), alice);
        assertEq(auction.pendingReturns(address(evil)), 1 ether);
    }
}

Dacă bid returnează imediat banii fostului lider (payable(highestBidder).transfer(highestBid)), apelul lui Alice dă revert, iar atacatorul rămâne lider pentru totdeauna. Testul transformă riscul teoretic într-un eșec vizibil.

Aceeași tehnică pentru alte scenarii:

  • un receptor care reintră în contract din receive (reentrancy);
  • un token care întoarce false în loc să dea revert;
  • un receptor care consumă tot gazul primit;
  • un contract care răspunde greșit la onERC721Received.

Le păstrezi într-un folder de „actori” reutilizabili (test/mocks/), ca fiecare contract nou să fie testat contra lor.

Ce urmărește intervievatorul: Se verifică dacă știi să testezi din perspectiva atacatorului, nu doar drumul fericit. Candidații buni scriu contracte ostile în teste din reflex.

96 Mid

Un test Foundry eșuează cu un revert fără mesaj adânc într-un lanț de apeluri. Cum afli ce apel a eșuat și de ce? Cum analizezi o tranzacție eșuată deja de pe rețea?

Răspuns scurt: Rulezi testul cu -vvvv pentru trace-ul complet de apeluri, cu argumente, valori returnate și locul revert-ului. Adaugi console.log din forge-std dacă ai nevoie de valori intermediare. O tranzacție de pe rețea o reiei local cu cast run <hash>, care afișează același tip de trace.

Nivelurile de detaliu în Foundry:

  • -vv: loguri (console.log);
  • -vvv: trace-uri pentru testele care eșuează;
  • -vvvv: trace-uri pentru toate testele, plus setUp;
  • -vvvvv: și operațiile de storage.

Trace-ul arată fiecare apel ca arbore: contractul, funcția decodată, argumentele, gazul și rezultatul. Revert-ul apare la nodul care l-a produs, iar dacă ai etichetat adresele (makeAddr, vm.label), vezi nume, nu adrese.

SOLIDITY
import {console} from "forge-std/console.sol";
console.log("shares", shares, "assets", assets);

Pentru un revert fără date, cauzele obișnuite sunt: un require fără mesaj, un apel către o adresă fără cod, decodarea eșuată a unui răspuns, o eroare custom dintr-un contract al cărui ABI nu e cunoscut. Pentru ultima, cast 4byte <selector> caută numele erorii după selector, iar cast decode-error decodează datele dacă ai semnătura.

Pentru o tranzacție eșuată pe rețea:

BASH
cast run 0xHASH --rpc-url $RPC_URL

Reia tranzacția pe starea blocului respectiv și afișează trace-ul. Cu --debug intri în debugger-ul interactiv, pas cu pas pe opcode-uri. Exploratorii și servicii precum Tenderly oferă aceeași informație într-o interfață grafică.

Abordarea sistematică: reproduci local (test sau fork la blocul tranzacției), izolezi apelul care eșuează, scrii un test care eșuează din același motiv, apoi repari și păstrezi testul ca protecție împotriva regresiei.

Ce urmărește intervievatorul: Se verifică eficiența la depanare, o abilitate zilnică. Candidații fără experiență reală nu știu de nivelurile de verbozitate sau de cast run.

Eroarea, în practică:Transaction reverted without a reason string

97 Mid

Testele trec local, dar pe Sepolia aceeași funcție dă revert. Cum depanezi, pas cu pas?

Răspuns scurt: Compar condițiile, nu codul: adrese, solduri, aprobări, parametri de deploy, versiunea compilatorului și a EVM-ului, chainId. Reiau tranzacția eșuată cu cast run, apoi reproduc situația într-un test pe fork al Sepolia, la blocul tranzacției, și repar ce diferă.

Structura răspunsului: ipoteze, date, reproducere, reparare, prevenire.

Diferențele tipice dintre testul local și rețeaua reală:

  • starea: contul nu are tokeni sau aprobarea necesară, contractul nu a fost inițializat, un rol nu a fost acordat după deploy;
  • adresele: scriptul de deploy a folosit o adresă de token sau oracol greșită pentru acea rețea; un contract de care depinzi nu există pe Sepolia;
  • parametrii de deploy: argumente de constructor diferite de cele din test, de exemplu un timestamp în trecut;
  • setările de compilare: o versiune EVM mai nouă decât suportă rețeaua (de exemplu opcode-uri absente pe o rețea compatibilă EVM);
  • particularități ale contractelor reale: tokenul de test se comportă altfel decât mock-ul;
  • gazul: estimarea a fost făcută pe altă stare.

Pași concreți:

  • citesc trace-ul tranzacției cu cast run 0xHASH --rpc-url $SEPOLIA_RPC sau într-un explorer care decodează erorile;
  • verific starea relevantă cu cast call (solduri, allowance, owner, paused);
  • scriu un test pe fork, fixat la blocul tranzacției, care face exact același apel cu același expeditor (vm.prank); acum am un caz reproductibil;
  • repar cauza: scriptul de deploy, configurarea sau codul.

Prevenire: scripturile de deploy (forge script) sunt testate și ele, pe fork; după deploy rulez un script de verificare care citește configurația contractului (roluri, adrese, parametri) și o compară cu cea așteptată; diferențele de configurare între rețele stau într-un singur fișier.

Ce urmărește intervievatorul: Se verifică abordarea sistematică a unei probleme reale de mediu. Răspunsul slab e „mai rulez o dată” sau modificarea codului fără a înțelege cauza.

98 Mid

Un client îți trimite un contract găsit pe internet și vrea să-l pună în producție în două zile, cu fondurile utilizatorilor. Cum procedezi?

Răspuns scurt: Nu promit un rezultat sigur în două zile. Clarific scopul și riscul, verific proveniența și versiunea, compar codul cu implementări cunoscute, rulez uneltele automate, scriu teste pentru fluxurile critice și livrez un raport scris de riscuri, cu recomandarea unui audit sau a unei lansări limitate.

Structura: înțelegerea cererii, evaluarea, livrabil, recomandare.

Înțelegerea cererii: ce trebuie să facă contractul, câți bani vor fi în el, cine îl administrează, de ce termenul de două zile. Uneori termenul vine dintr-o promisiune de marketing care poate fi renegociată când clientul înțelege riscul.

Evaluarea, în ordinea valorii:

  • proveniența: de unde vine, ce licență are, dacă e o copie a unui proiect cunoscut sau a fost modificat; compar cu sursa originală și cu implementările OpenZeppelin echivalente;
  • versiunea de Solidity și dependențele; cod vechi, înainte de 0.8, aduce riscuri de overflow;
  • unelte automate: Slither, Aderyn, compilare fără warning-uri;
  • review manual concentrat pe funcțiile care mută bani și pe cele de administrare;
  • teste Foundry pentru fluxurile principale și pentru cazurile de eroare, plus un fuzz rapid pe calcule.

Livrabilul: un document scurt cu ce am verificat, ce am găsit (cu gravitate), ce nu am putut verifica în timpul dat și recomandări.

Recomandarea, formulată ca opțiuni, nu ca refuz:

  • lansare cu limite: plafon de depozite, pauză disponibilă, administrare prin multisig;
  • audit extern înainte de a ridica plafonul;
  • un program de bug bounty după lansare.

Decizia finală e a clientului, dar trebuie luată în cunoștință de cauză și documentată. Nu semnez o garanție de securitate pe un cod pe care nu l-am putut verifica complet.

Ce urmărește intervievatorul: Se verifică judecata profesională și comunicarea riscului către un client. Răspunsurile slabe fie promit totul, fie refuză fără să ofere alternative.

99 Senior

Echipa vrea să lanseze vineri pe mainnet un contract nou, fără audit extern, pentru că „testele trec”. Ești cel mai experimentat dezvoltator de smart contracts din echipă. Ce faci?

Răspuns scurt: Exprim riscul cu fapte despre cod. Propun opțiuni: review intern structurat, unelte automate, lansare cu plafon și pauză, audit înainte de ridicarea plafonului. Decizia o ia explicit responsabilul de produs, documentat.

Situație, acțiuni, rezultat.

Înțeleg întâi de ce vineri: o campanie, un partener, o promisiune publică. Dacă nu știu motivul, nu pot propune alternative realiste.

Pregătesc argumentele concrete:

  • ce face contractul și câți bani va ține, deci impactul unui bug;
  • ce acoperă testele și ce nu (invarianți, fuzzing, integrări reale, scenarii ostile);
  • ce părți sunt noi față de cod deja auditat (de exemplu logică proprie peste OpenZeppelin);
  • ce înseamnă un bug după lansare: fonduri pierdute ireversibil, nu un hotfix.

Propun opțiuni, nu doar „nu”:

  • review intern în următoarele zile, cu un checklist și cu altcineva decât autorul;
  • unelte automate rulate și constatări tratate;
  • lansare cu limite: plafon pe depozite sau pe valoarea totală, funcție de pauză, rolurile de administrare pe multisig;
  • audit extern programat, cu ridicarea plafonului condiționată de raport;
  • bug bounty de la lansare.

Decizia: o ia persoana responsabilă de produs, în scris, cu riscurile cunoscute. Dacă se merge înainte, mă asigur că există monitorizare și un plan de reacție (cine poate pune pauză, cum comunicăm).

Ce nu fac: nu blochez în tăcere, nu aprob formal ceva ce consider nesigur și nu transform discuția într-un conflict personal. Rezultatul bun e o decizie asumată, cu riscul redus cât se poate în timpul disponibil.

Ce urmărește intervievatorul: Se verifică leadership-ul tehnic și capacitatea de a gestiona presiunea de business. Răspunsurile slabe sunt fie cedarea completă, fie refuzul fără alternative.

100 Senior

Contractul tău tocmai a fost lansat și ține fondurile utilizatorilor. Ce monitorizezi după lansare și ce plan ai pregătit dinainte pentru un incident?

Răspuns scurt: Monitorizez events-urile critice (schimbări de roluri, upgrade-uri, pauze), transferurile mari, invarianți calculați off-chain și starea dependențelor (oracole, tokeni). Planul de incident e scris dinainte: cine poate pune pauză și cum, cum se contactează semnatarii multisig, cine comunică public și cum se face analiza după incident.

Monitorizarea, pe trei niveluri:

  • administrare: alertă pentru orice RoleGranted, OwnershipTransferred, Upgraded, Paused, schimbare de parametri. Orice astfel de event neplanificat poate însemna o cheie compromisă;
  • flux de bani: retrageri sau depuneri peste un prag, ieșiri neobișnuit de rapide, multe tranzacții de la aceeași adresă nouă;
  • invarianți și dependențe: un script care verifică periodic, de exemplu, că suma datoriilor e acoperită de active, că prețul oracolului e recent și apropiat de alte surse, că tokenii integrați nu s-au schimbat (un upgrade al unui token extern poate schimba comportamentul).

Uneltele pot fi un serviciu de alertare pe events (de exemplu Tenderly sau Forta) sau un serviciu propriu care citește lanțul, cu notificări într-un canal urmărit permanent.

Planul de incident, scris și exersat înainte de lansare:

  • cine are dreptul să pună pauză și cum se face rapid (o cheie de guardian, un script pregătit, eventual automat la anumite alerte);
  • lista de contact a semnatarilor multisig și pragul necesar, pentru că un multisig care nu se poate aduna în câteva ore e inutil într-un incident;
  • cine evaluează tehnic și cine comunică public, cu mesaje pregătite;
  • opțiunile tehnice: pauză, upgrade, migrare, recuperare de fonduri, contact cu echipe de securitate;
  • la final, o analiză post-incident fără vinovați, cu cauză, cronologie și măsuri.

Exercițiul pe un fork sau pe testnet, în care echipa chiar pune pauză și face un upgrade, arată unde planul nu funcționează.

Ce urmărește intervievatorul: Se verifică gândirea operațională a unui senior, dincolo de cod. Mulți candidați se opresc la deploy și nu au un plan pentru ce urmează.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Solidity, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Solidity scriind cod, nu doar citind

Curs Solidity și Smart Contracts: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.