Exerciții Solidity de la ușor la greu, fiecare cu cerința, un indiciu, soluția completă și explicația ei. Înveți de la zero cu Curs Solidity și Smart Contracts: primele 15 lecții sunt gratuite.
Le rezolvi direct pe pagină, în editorul Solidity, cu un blockchain local, exact ca în lecțiile cursului: scrii, apeși Verifică și afli imediat dacă e corect.
Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Pe pagina asta exersezi Solidity scriind contracte complete, de la un simplu contor până la tokeni ERC-20, colecții NFT, crowdfunding, escrow, licitații și un portofel multisig. Fiecare exercițiu descrie ce trebuie să facă un contract mic, dintr-o situație reală (magazin, catalog, rezervări, donații, abonamente), iar soluția îți dă codul complet (pragma ^0.8.20), explicat. Atingi tot ce contează la un interviu: tipuri și vizibilitate, mapping și struct, modifiers, erori custom, evenimente, ether și modelul retragerii, moșteniri și interfețe, contractele OpenZeppelin, apărarea împotriva reentrancy și checks-effects-interactions, optimizarea gas-ului și testarea contractelor.
Exercițiile sunt grupate pe capitole și merg de la ușor la greu în fiecare capitol. Fiecare se rezolvă direct în pagină, cu „Rezolvă în editor”: scrii contractul (sau, la capitolul de teste, fișierul de test) într-un editor cu compilatorul oficial Solidity 0.8.30 și un blockchain Ethereum local care rulează în browser, iar la „Rulează” un script publică și apelează contractul și îți spune dacă exercițiul e rezolvat. Ai la dispoziție zece conturi de test cu câte 100 ETH (ana, bogdan, cristina și ceilalți), versiuni compacte ale contractelor OpenZeppelin 5 acolo unde exercițiul le cere și teste în stilul Hardhat cu ethers v6 și Chai. Nimic de aici nu cere bani reali.
Harta exercițiilor
Trei insule, de la ușor la greu. Omulețul stă la exercițiul la care ai rămas: apasă pe orice exercițiu deschis ca să-l rezolvi.
Primele contracte: variabile de stare și funcții
1UșorGratuit Rezolvat
Numără vizitele unui contract și salvează ultimul vizitator
Scrie un contract ContorVizite care numără de câte ori a fost vizitat și ține minte adresa ultimului vizitator.
Contractul are două variabile de stare publice: vizite (de tip uint256, pornește de la 0) și ultimulVizitator (de tip address). Funcția viziteaza() poate fi apelată de oricine: crește contorul cu 1 și salvează în ultimulVizitator adresa celui care a apelat.
Exemplu: după ce ana și apoi bogdan apelează viziteaza(), vizite() întoarce 2, iar ultimulVizitator() întoarce adresa lui bogdan.
Scriptul exercițiului publică contractul, afișează contorul de la început, o pune pe ana și apoi pe bogdan să apeleze viziteaza(), afișează numărul de vizite și verifică dacă ultimul vizitator salvat este bogdan.
Rezultatul așteptat
La început: 0
Vizite: 2
Ultimul este Bogdan: true
Indiciu
Adresa celui care apelează funcția o găsești mereu în msg.sender.
Soluția
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract ContorVizite {
uint256 public vizite;
address public ultimulVizitator;
function viziteaza() external {
vizite += 1;
ultimulVizitator = msg.sender;
}
}
Explicația
Contractul păstrează două valori în storage, memoria permanentă a contractului de pe blockchain. Orice valoare scrisă acolo rămâne între tranzacții, de aceea contorul nu se resetează.
Pașii: declari uint256 public vizite (valoarea implicită a unui uint256 este 0, nu trebuie inițializată) și address public ultimulVizitator (implicit adresa zero). În viziteaza() crești contorul și salvezi msg.sender, adică adresa contului care a semnat tranzacția.
Am marcat funcția external pentru că este apelată doar din afară; public ar fi mers la fel. În Solidity 0.8 adunarea vizite += 1 este verificată automat: la depășire tranzacția ar fi anulată, nu ar reveni la zero.
Greșeala tipică la început este să crezi că citirea vizite() costă gas. Getter-ele sunt funcții view: apelate din afara blockchain-ului sunt gratuite, doar tranzacțiile care modifică starea se plătesc.
Scrie un contract Avizier care păstrează un mesaj de bun venit, pe cine l-a scris ultima dată și de câte ori a fost schimbat.
La publicare, mesajul pornește cu textul primit în constructor, iar autorul este cel care a publicat contractul. Funcția schimbaMesaj(string calldata nou) poate fi apelată de oricine, dar respinge mesajul gol și mesajele mai lungi de 100 de octeți cu mesajul de eroare Mesaj invalid. După fiecare schimbare se actualizează autor și crește modificari.
Exemplu: publici cu "Salut!", bogdan apelează schimbaMesaj("Bine ai venit la curs"); mesaj() întoarce noul text, autor() adresa lui bogdan, modificari() 1.
Scriptul exercițiului publică avizierul cu "Salut!" (din contul anei), îl pune pe bogdan să schimbe mesajul, afișează mesajul, autorul și numărul de modificări, apoi încearcă un mesaj gol, unul de 101 octeți și unul de exact 100 de octeți.
Rezultatul așteptat
Mesaj inițial: Salut!
Autor inițial este Ana: true
Mesaj nou: Bine ai venit la curs
Autor nou este Bogdan: true
Modificări: 1
Mesaj gol: Mesaj invalid
Mesaj prea lung: Mesaj invalid
100 de octeți acceptați, modificări: 2
Indiciu
Lungimea unui string se află convertindu-l în bytes: bytes(text).length.
Soluția
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Avizier {
string public mesaj;
address public autor;
uint256 public modificari;
constructor(string memory initial) {
mesaj = initial;
autor = msg.sender;
}
function schimbaMesaj(string calldata nou) external {
uint256 lungime = bytes(nou).length;
require(lungime > 0 && lungime <= 100, "Mesaj invalid");
mesaj = nou;
autor = msg.sender;
modificari += 1;
}
}
Explicația
Exercițiul combină trei lucruri de bază: constructorul, tipul string și require.
Constructorul primește textul inițial cu string memory, pentru că datele de la publicare stau temporar în memorie. În schimbaMesaj parametrul este string calldata: datele rămân în zona read-only a tranzacției și nu se copiază, ceea ce e mai ieftin pentru funcțiile external.
Un string în Solidity nu are .length, de aceea îl convertești în bytes. Atenție: lungimea este în octeți, nu în caractere; o literă cu diacritice ocupă 2 octeți în UTF-8, deci limita de 100 este o limită de spațiu, nu de litere.
require(conditie, "mesaj") anulează toată tranzacția dacă condiția e falsă: nimic din ce s-a scris înainte nu rămâne, iar apelantul primește mesajul. Greșeala tipică este să faci validarea după ce ai modificat deja starea; ordinea corectă este întâi verificările, apoi scrierile.
Scrie un contract CalculatorTva cu două funcții pure care calculează TVA-ul pentru prețuri exprimate în bani (1 leu = 100 de bani), pentru că Solidity nu are numere cu zecimale.
pretCuTva(uint256 pretBani, uint256 cotaProcent) întoarce prețul final, rotunjit în jos la ban;
valoareTva(uint256 pretBani, uint256 cotaProcent) întoarce doar TVA-ul.
Cota nu poate depăși 100 (altfel revert cu Cota invalida).
Exemplu: un produs de 125,00 lei (12500 de bani) cu cota 19 costă 14875 de bani, iar TVA-ul este 2375. Pentru 9,99 lei (999) cu cota 19 rezultă 1188.
Scriptul exercițiului calculează prețul pentru 12500 și 999 de bani cu cota 19, pentru 10000 de bani cu cota 9, TVA-ul cu cota 0 și încearcă o cotă de 150.
Rezultatul așteptat
125 lei cu 19%: 14875
TVA: 2375
9,99 lei cu 19%: 1188
Cota 9%: 10900
Cota 0%: 0
Cota 150: Cota invalida
Indiciu
Înmulțește întâi și împarte la 100 abia la final, ca să nu pierzi precizie.
Soluția
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract CalculatorTva {
function pretCuTva(uint256 pretBani, uint256 cotaProcent) public pure returns (uint256) {
require(cotaProcent <= 100, "Cota invalida");
return pretBani * (100 + cotaProcent) / 100;
}
function valoareTva(uint256 pretBani, uint256 cotaProcent) external pure returns (uint256) {
return pretCuTva(pretBani, cotaProcent) - pretBani;
}
}
Explicația
În Solidity nu există float sau double, așa că banii se țin mereu într-o unitate mică întreagă: bani în loc de lei, wei în loc de ether. Calculul devine aritmetică pe numere întregi.
Ordinea operațiilor contează: pretBani * (100 + cota) / 100 înmulțește întâi și abia apoi împarte, deci pierzi cel mult o fracțiune de ban. Dacă ai scrie pretBani / 100 * (100 + cota), pentru 999 de bani ai obține 9 * 119 = 1071, adică ai pierdut aproape un leu.
Împărțirea întreagă rotunjește mereu în jos (trunchiază). Dacă un magazin vrea rotunjire la cel mai apropiat ban, adaugă jumătate din împărțitor înainte: (x + 50) / 100.
valoareTva refolosește pretCuTva, care e public tocmai ca să poată fi apelată și din interior. Funcțiile marcate pure sunt verificate de compilator: dacă ar citi o variabilă de stare, compilarea ar da eroare.
Cutie de sugestii pe care doar proprietarul o poate goli
Scrie un contract CutieSugestii în care oricine poate lăsa o sugestie, dar doar cel care a publicat contractul poate goli cutia.
Proprietarul se salvează în constructor într-o variabilă publică proprietar. Sugestiile stau într-un array public de texte sugestii. Funcțiile:
adaugaSugestie(string calldata text): adaugă textul la final;
numarSugestii(): întoarce câte sugestii sunt;
golesteCutia(): șterge toate sugestiile; dacă o apelează altcineva decât proprietarul, tranzacția eșuează cu Doar proprietarul.
Exemplu: bogdan și cristina lasă câte o sugestie, numarSugestii() întoarce 2; după ce ana (proprietarul) golește cutia, întoarce 0.
Scriptul exercițiului publică cutia din contul anei, bogdan și cristina lasă câte o sugestie, afișează numărul și prima sugestie, îl pune pe bogdan să încerce golirea, apoi ana golește cutia și dan mai adaugă o sugestie.
Rezultatul așteptat
Sugestii: 2
Prima: Mai multe exercitii
Bogdan golește: Doar proprietarul
După golire: 0
Se poate folosi din nou: 1
Indiciu
delete aplicat unui array dinamic îl aduce la lungimea 0.
Soluția
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract CutieSugestii {
address public proprietar;
string[] public sugestii;
constructor() {
proprietar = msg.sender;
}
function adaugaSugestie(string calldata text) external {
sugestii.push(text);
}
function numarSugestii() external view returns (uint256) {
return sugestii.length;
}
function golesteCutia() external {
require(msg.sender == proprietar, "Doar proprietarul");
delete sugestii;
}
}
Explicația
Contractul arată tiparul de bază al oricărei aplicații: o regulă de acces (doar proprietarul face ceva) și date adăugate de oricine.
proprietar = msg.sender în constructor salvează adresa celui care a publicat contractul, pentru că în constructor msg.sender este chiar contul care trimite tranzacția de publicare. Din acel moment, orice funcție poate compara msg.sender cu proprietar.
sugestii.push(text) adaugă la finalul array-ului din storage, iar delete sugestii îl golește. Pentru un array mare, delete costă gas proporțional cu numărul de elemente (fiecare slot e curățat), deci într-un contract real ai limita numărul de sugestii sau ai folosi un contor de „versiune”.
Greșeala tipică: să uiți verificarea din golesteCutia(). Fără require, oricine ar putea șterge datele, iar pe blockchain nu există „admin” implicit: contractul face exact ce scrie în cod și nimic altceva.
5UșorGratuit Rezolvat
Păstrează temperatura minimă și maximă înregistrată
Scrie un contract Termometru care primește citiri de temperatură (pot fi negative) și ține minte cea mai mică și cea mai mare valoare.
Folosește int256 pentru minima și maxima (ambele publice) și o variabilă numarCitiri. Funcția inregistreaza(int256 grade): la prima citire setează atât minima, cât și maxima la valoarea primită; la următoarele actualizează doar ce s-a schimbat. Funcția amplitudine() întoarce diferența maxima - minima.
Exemplu: după citirile 5, -3 și 12, minima() este -3, maxima() este 12, iar amplitudine() este 15.
Scriptul exercițiului înregistrează 5, apoi -3 și 12 și afișează minima, maxima, amplitudinea și numărul de citiri; un al doilea termometru primește doar valori negative (-7 și -2), ca să se vadă că prima citire contează.
Rezultatul așteptat
După 5: 5 5
Minima: -3
Maxima: 12
Amplitudine: 15
Citiri: 3
Doar negative: -7 -2
Indiciu
Nu porni minima de la 0: o primă citire de 5 grade nu ar fi actualizat-o niciodată.
Soluția
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Termometru {
int256 public minima;
int256 public maxima;
uint256 public numarCitiri;
function inregistreaza(int256 grade) external {
if (numarCitiri == 0) {
minima = grade;
maxima = grade;
} else {
if (grade < minima) minima = grade;
if (grade > maxima) maxima = grade;
}
numarCitiri += 1;
}
function amplitudine() external view returns (int256) {
return maxima - minima;
}
}
Explicația
uint256 nu poate ține valori negative, de aceea pentru temperaturi folosești int256, întregul cu semn. Ambele tipuri ocupă 32 de octeți; int256 merge de la aproximativ -5,7 * 10^76 la +5,7 * 10^76.
Problema interesantă este inițializarea. Toate variabilele de stare pornesc de la 0, deci dacă ai compara direct, o serie de citiri pozitive (5, 8, 12) ar lăsa minima la 0, o valoare care nici nu a fost măsurată. Soluția este să tratezi separat prima citire, folosind numarCitiri == 0 ca semnal.
amplitudine() este view pentru că doar citește starea. Pe int256, scăderea maxima - minima este verificată de compilator: dacă rezultatul ar ieși din interval, tranzacția s-ar anula.
Alternativa ar fi să pornești minima de la type(int256).max și maxima de la type(int256).min în constructor; e corectă, dar amplitudine() ar da overflow înainte de prima citire.
Scrie un contract Calendar cu funcția esteBisect(uint256 an) care întoarce true dacă anul este bisect și false altfel, plus funcția zileInAn(uint256 an) care întoarce 366 sau 365.
Întoarce statisticile vânzărilor unui magazin dintr-o funcție
Scrie un contract StatisticiMagazin care înregistrează vânzări și întoarce dintr-o singură funcție numărul lor, totalul, cea mai mare vânzare și media.
Folosește constant și immutable pentru comisionul unei platforme
Scrie un contract PlatformaVanzari care calculează comisionul platformei dintr-o vânzare, folosind o constantă pentru procent și valori immutable setate la publicare.
Calculează dobânda simplă cu precizie de 18 zecimale
Scrie un contract CalculatorDobanda care calculează dobânda simplă pentru un depozit, folosind numere scalate cu 1e18 (convenția „WAD”) în loc de zecimale.
Whitelist: verifică rapid o adresă și listează toți membrii
Scrie un contract ListaAlba pentru accesul anticipat la o vânzare, în care proprietarul adaugă și scoate adrese, iar oricine verifică rapid dacă o adresă e pe listă și poate citi lista întreagă.
Registru de cărți: împrumută și returnează după ID
Scrie un contract Biblioteca în care bibliotecarul (cel care publică) adaugă cărți cu ID-uri incrementale, iar cititorii le împrumută și le returnează.
Clasament on-chain: păstrează sortate primele 3 scoruri
Scrie un contract Clasament pentru un joc, care păstrează primele 3 scoruri și jucătorii lor, mereu sortate descrescător, fără să stocheze toate scorurile.
Scrie de mână un modifier onlyOwner și transferul proprietății
Scrie un contract PanouAnunturi cu un modifier onlyOwner scris de tine (fără biblioteci), care protejează publicarea anunțurilor și transferul proprietății.
Emite un eveniment la fiecare intrare într-o sală de fitness
Scrie un contract SalaFitness care înregistrează intrările membrilor și emite un eveniment pentru fiecare, ca aplicația să poată afișa istoricul fără să-l stocheze pe blockchain.
Scrie un contract Cinema în care utilizatorii își declară vârsta o singură dată, iar vizionarea filmelor este restricționată printr-un modifier cu parametru.
Cooldown: permite o revendicare de puncte o dată la 24 de ore
Scrie un contract RobinetPuncte din care fiecare utilizator poate revendica 10 puncte, dar cel mult o dată la 24 de ore, folosind un modifier de tip cooldown.
Mașină de stări pentru un concurs: înscrieri, desfășurare, încheiere
Scrie un contract Concurs care trece prin etapele Inscrieri, Desfasurare și Incheiat, cu un modifier inEtapa(Etapa e) care permite fiecare funcție doar în etapa potrivită.
Păstrează istoricul de preț al unui produs doar în evenimente
Scrie un contract Preturi pentru un magazin, în care administratorul schimbă prețurile produselor, iar istoricul complet al modificărilor se poate reconstrui din evenimente, fără să fie salvat în storage.
Comandă cu termen de anulare: modifiers combinate și erori custom
Scrie un contract ComenziMagazin în care clienții plasează comenzi, le pot anula doar în prima oră și doar înainte de expediere, iar vânzătorul le expediază.
Primește ether direct în contract cu funcția receive
Scrie un contract CutieDonatii care acceptă donații în ether trimise direct la adresa lui, fără să apelezi vreo funcție, ca la un transfer obișnuit dintr-un portofel.
Proprietarul retrage tot ether-ul din contract cu call
Scrie un contract CasaMarcat care încasează plăți în ether de la oricine și îi permite doar proprietarului să retragă tot soldul la o adresă aleasă de el.
Modelul retragerii: fiecare își retrage singur câștigurile
Scrie un contract PlatformaFreelance în care clienții plătesc lucrări către freelanceri, iar banii nu sunt trimiși imediat, ci se acumulează și fiecare freelancer și-i retrage singur (pull over push).
Împarte automat o plată între trei asociați după procente
Scrie un contract ImpartireVenit pentru o firmă cu trei asociați, care împarte fiecare plată primită după procente fixe, stabilite la publicare, și îi lasă pe asociați să-și retragă partea.
Scrie un contract DepozitBlocat în care fiecare utilizator depune ether care rămâne blocat o perioadă aleasă de el (de exemplu economii pentru o vacanță) și se poate retrage doar după expirare.
Plătește mai mulți câștigători fără ca unul să blocheze plata
Scrie un contract PremiiConcurs care plătește premiile mai multor câștigători dintr-o singură tranzacție, dar fără ca un destinatar care refuză ether-ul să blocheze plata celorlalți.
Contract abstract pentru forme geometrice cu arie și perimetru
Scrie un contract abstractForma care declară funcțiile arie() și perimetru() fără implementare și o funcție concretă descriere(), apoi două contracte concrete:
Folosește super ca să adaugi un jurnal peste funcția părintelui
Scrie un contract Cont cu o funcție virtualdepune(uint256 suma) care crește soldul, apoi un contract ContCuJurnal is Cont care suprascrie funcția, apelează logica părintelui cu super.depune(suma) și adaugă un eveniment și un contor.
Moștenire multiplă: ordinea de liniarizare și lanțul super
Scrie un sistem de validări pentru transferuri de puncte cu moștenire multiplă, în care fiecare contract adaugă o regulă și apelează super, iar ordinea de execuție se vede într-un jurnal.
Scrie o bibliotecă Procente cu funcții internal pure pentru calcule cu puncte de bază și folosește-o într-un contract Reduceri cu directiva using Procente for uint256.
Apel de nivel jos cu abi.encodeWithSignature și decodarea rezultatului
Scrie un contract Telecomanda care apelează funcțiile unui contract Termostat fără să-i cunoască tipul la compilare, folosind call de nivel jos, apoi decodează rezultatul cu abi.decode.
CREATE2: află adresa unui contract înainte să-l publici
Scrie un contract FabricaPortofele care creează portofele simple cu CREATE2, astfel încât adresa fiecărui portofel să poată fi calculată dinainte, pornind de la proprietar și un salt.
Taxe înlocuibile: deleagă calculul unui contract strategie
Scrie un contract Marketplace care calculează comisionul fiecărei vânzări printr-un contract extern înlocuibil (tiparul strategy), ca regulile de comision să poată fi schimbate fără să republici marketplace-ul.
Scrie un token ERC-20 numit Leu Digital cu simbolul LDG, folosind contractul ERC20 din OpenZeppelin, în care tot supply-ul inițial ajunge la cel care publică.
Scrie un token ERC-20 PunctBonus (simbol PBN) pentru un program de fidelitate, cu doar 2 zecimale în loc de 18, astfel încât 1 punct să fie 100 de unități, ca leii și banii.
Colecție NFT ERC-721 în care doar proprietarul emite tokeni
Scrie o colecție de NFT-uri BileteMuzeu (simbol MUZ) cu ERC721 și Ownable din OpenZeppelin, în care doar proprietarul contractului poate emite bilete către vizitatori.
Token cu plafon maxim pe care doar proprietarul îl poate emite
Scrie un token ERC-20 TokenComunitate (simbol TCM) cu un plafon maxim de 1000000 de tokeni, în care doar proprietarul poate emite tokeni noi, folosind ERC20Capped și Ownable din OpenZeppelin.
Metadate NFT: construiește tokenURI din baseURI și ID
Scrie o colecție NFT Diplome cu ERC721 și Ownable, în care metadatele fiecărui token se găsesc la adresa baseURI + id + ".json", iar proprietarul poate muta metadatele o singură dată, apoi le blochează definitiv.
NFT cu mint public: preț, limită totală și limită per portofel
Scrie o colecție NFT CarduriArta cu ERC721 și Ownable, în care oricine poate emite (mint) tokeni plătind în ether, cu o limită totală de 100 de tokeni și maximum 3 pe portofel.
Airdrop: trimite tokeni la mai multe adrese într-o tranzacție
Scrie un contract Airdrop care distribuie tokeni ERC-20 către o listă de adrese într-o singură tranzacție, folosind SafeERC20 și o singură aprobare de la organizator.
Staking: blochează tokeni și primește recompense pe secundă
Scrie un contract Staking în care utilizatorii blochează tokeni ERC-20 și primesc recompense în același token, cu o rată fixă de recompensă pe secundă împărțită proporțional la toți cei care au tokeni blocați.
Scrie o colecție DiplomaSoulbound cu ERC721 și Ownable (OpenZeppelin 5), în care tokenii pot fi emiși și arși, dar nu pot fi transferați între conturi:
Token ERC-20 cu taxă de 2% la transfer către trezorerie
Scrie un token ERC-20 TokenCuTaxa (OpenZeppelin 5) care reține automat 2% din fiecare transfer între utilizatori și îi trimite la o adresă de trezorerie, fără taxă la emitere, la ardere și pentru adresele scutite.
Restricționează funcțiile de administrare cu Ownable din OpenZeppelin
Scrie un contract ConfigurareMagazin care folosește Ownable din OpenZeppelin 5 ca să protejeze setările unui magazin online (taxa de livrare și pragul de livrare gratuită), cu transfer și renunțare la proprietate.
Verifică un voucher semnat cu ecrecover și blochează reutilizarea
Scrie un contract VoucherePuncte în care un emitent de încredere semnează în afara blockchain-ului vouchere de puncte, iar beneficiarii le revendică în contract, fără ca emitentul să plătească gas pentru fiecare voucher.
Parametri calldata în loc de memory pentru funcțiile external
Scrie două variante ale unei funcții care primește o listă de coduri de produs și întoarce câte coduri sunt mai mari decât un prag, una cu parametrul uint256[] memory și una cu uint256[] calldata, și compară costul.
Scrie două variante ale aceleiași validări pentru un sistem de rezervări, una cu require și mesaje text lungi, una cu erori custom, și compară costul de publicare și costul unui revert.
Împachetează variabilele în sloturi de storage pentru gas mai mic
Scrie două variante ale unui struct pentru profilul unui utilizator, una cu câmpurile într-o ordine nepotrivită, care ocupă 3 sloturi de storage, și una reordonată, care încape în 2 sloturi, apoi compară costul primei salvări.
Bitmap: 256 de revendicări într-un singur slot de storage
Scrie un contract RevendicariBitmap care ține evidența revendicărilor unui airdrop pentru indexuri de la 0 la 9999, folosind un bitmap (mapping(uint256 => uint256), câte 256 de indexuri într-un cuvânt), și compară cu varianta RevendicariBool cu mapping(uint256 => bool).
Testează un invariant de sold pe multe valori, inclusiv cazurile limită
Scrie teste care verifică proprietăți valabile pentru orice sumă la contractul Portofel (depuneri și retrageri de ether per utilizator), nu doar pentru un exemplu ales de tine.
Cutie de bacșiș cu mesaj pentru un creator de conținut
Scrie un contract Bacsis prin care fanii unui creator de conținut îi trimit bacșiș în ether împreună cu un mesaj scurt, iar creatorul retrage banii când vrea.
Scrie un contract Vault în care utilizatorii depun un token ERC-20 și primesc acțiuni (shares) proporționale cu partea lor din fond; când fondul crește (de exemplu din dobânzi trimise în vault), valoarea fiecărei acțiuni crește.
Portofel multisig 2 din 3 pentru plățile unei firme
Scrie un portofel Multisig pentru o firmă cu trei administratori, în care orice plată în ether are nevoie de aprobarea a cel puțin 2 dintre ei înainte de a fi executată.
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Exercițiile de aici sunt gândite ca la job: date concrete, cerințe clare și soluții pe care le poți explica la un interviu de Solidity.
Învață Solidity de la zero, cu exerciții la fiecare lecție
Curs Solidity și Smart Contracts: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.