...
← Curs Solidity și Smart Contracts: toate lecțiile
Lecția 14 · Events

Events: jurnalul contractului

Un contract nu poate trimite notificări și nu poate apela o aplicație web. În schimb, poate emite evenimente: înregistrări în receipt-ul tranzacției pe care aplicațiile le ascultă și le caută. În această lecție declari evenimente, le emiți și le citești din JavaScript.

De ce evenimente

Imaginează-ți un magazin online care trebuie să afle când cineva plătește prin contract. Ar putea citi variabilele contractului la fiecare secundă, dar nu ar ști ce s-a schimbat și când. Evenimentele rezolvă problema: contractul scrie un mesaj în jurnal (log), iar aplicația primește exact acel mesaj.

Contract Contorcreste()emit Crescut(numar);numar = 2 (storage)Receipt-urile (2 tranzacții)log: CrescutvaloareNoua = 1bloc 2log: CrescutvaloareNoua = 2bloc 3Aplicația webactualizează ecranulNotificăritrimite un mesajExplorator / indexeristoric căutabilcontractele NU pot citi log-urile; ele sunt pentru lumea din afara lanțului
Fiecare apel creste() emite Crescut cu noua valoare; log-ul ajunge în receipt, iar aplicațiile din afara lanțului îl citesc.
  • Evenimentele se salvează în receipt-ul tranzacției, nu în storage.
  • Sunt mult mai ieftine decât variabilele de stare.
  • Contractele nu le pot citi înapoi; sunt pentru aplicații, exploratoare și indexatoare.
  • Dacă tranzacția dă revert, evenimentele ei dispar și ele.

Declari și emiți

Un eveniment se declară în contract cu event Nume(tipuri) și se emite cu emit Nume(valori). Prin convenție, numele începe cu literă mare și descrie ce s-a întâmplat: ComandaNoua, Crescut, Transfer.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Comenzi {
    uint public total;

    event ComandaNoua(address indexed client, uint suma, string produs);

    function comanda(uint suma, string memory produs) public {
        total = total + suma;
        emit ComandaNoua(msg.sender, suma, produs);
    }
}
const comenzi = await deploy("Comenzi");
const tx = await comenzi.comanda(120, "Carte");
const rc = await tx.wait();
const ev = rc.logs[0];
console.log("Eveniment:", ev.eventName);
console.log("Client e Ana:", ev.args.client === ana.address);
console.log("Suma:", ev.args.suma, "| Produs:", ev.args.produs);
Eveniment: ComandaNoua
Client e Ana: true
Suma: 120 | Produs: Carte

În receipt, rc.logs conține evenimentele tranzacției, deja decodate: eventName și args, cu argumentele accesibile după nume (ev.args.suma) sau poziție (ev.args[1]).

indexed: evenimente căutabile

Cuvântul indexed (maximum 3 parametri pe eveniment) pune valoarea într-un topic, după care nodurile pot filtra rapid. Așa găsești doar comenzile unui anumit client, fără să descarci tot istoricul:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Comenzi {
    uint public total;

    event ComandaNoua(address indexed client, uint suma, string produs);

    function comanda(uint suma, string memory produs) public {
        total = total + suma;
        emit ComandaNoua(msg.sender, suma, produs);
    }
}
const comenzi = await deploy("Comenzi");
await (await comenzi.comanda(120, "Carte")).wait();
await (await comenzi.connect(bogdan).comanda(45, "Pix")).wait();
await (await comenzi.comanda(300, "Rucsac")).wait();

const aleAnei = await comenzi.queryFilter(comenzi.filters.ComandaNoua(ana.address));
for (const e of aleAnei) {
    console.log(`Blocul ${e.blockNumber}: ${e.args.produs}, ${e.args.suma} lei`);
}
console.log("Toate comenzile:", (await comenzi.queryFilter("ComandaNoua")).length);
Blocul 2: Carte, 120 lei
Blocul 4: Rucsac, 300 lei
Toate comenzile: 3

comenzi.filters.ComandaNoua(ana.address) construiește filtrul după primul parametru indexat, iar queryFilter caută în blocurile minate. Comanda lui Bogdan din blocul 3 nu apare în lista Anei.

Ce indexezi

Indexează valorile după care vei căuta: adrese (expeditor, destinatar), ID-uri. Textele și sumele rămân de obicei neindexate: un string indexat se salvează doar ca hash și nu mai poate fi citit.

Cât costă un eveniment

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Cost {
    uint public ultima;
    event Nota(uint valoare);

    function salveaza(uint v) public {
        ultima = v;
    }

    function anunta(uint v) public {
        emit Nota(v);
    }
}
const c = await deploy("Cost");
const gStorage = await gasFolosit(c.salveaza(7));
const gLog = await gasFolosit(c.anunta(7));
console.log("Evenimentul e mai ieftin decât storage-ul:", gLog < gStorage);
Evenimentul e mai ieftin decât storage-ul: true

Un log costă aproximativ 375 gas, plus 375 pentru fiecare topic și 8 gas pentru fiecare octet de date, mult sub cei 22 100 ai unei scrieri noi în storage. De aceea istoricul (cine a plătit, când, cât) se ține de obicei în evenimente, iar în storage doar ce are nevoie contractul ca să funcționeze.

Greșeli frecvente

  • **Uitarea lui emit**: în Solidity 0.8 apelul unui eveniment fără emit nu compilează.
  • **Prea multe indexed**: maximum 3 parametri indexați pe eveniment (4 topic-uri cu semnătura).
  • Date importante doar în evenimente: dacă alt contract are nevoie de o valoare, ea trebuie să fie în storage; contractele nu citesc log-urile.
  • Emiterea înainte de verificări: pune emit după ce schimbarea a avut loc, la finalul funcției.

Exemple reale

Transfer

Orice token ERC-20 emite Transfer(from, to, value); portofelele îți construiesc istoricul din aceste evenimente.

Etherscan

Fila „Logs” a unei tranzacții arată evenimentele decodate.

The Graph

Indexatoarele citesc evenimentele și le pun într-o bază de date interogabilă pentru aplicații.

Exercițiul tău

Completează contractul Contor: declară evenimentul Crescut(uint valoareNoua) și emite-l în creste(), după ce mărești numar, cu noua valoare. Scriptul lecției apelează creste() de două ori și afișează numele și argumentul evenimentului din fiecare receipt.

  • Declară event Crescut(uint valoareNoua); în contract.
  • În creste(), după numar = numar + 1;, scrie emit Crescut(numar);.
Evenimentul se declară lângă variabile, iar emit se pune în funcție, după modificare.

Soluția exercițiului

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Contor {
    uint public numar;

    event Crescut(uint valoareNoua);

    function creste() public {
        numar = numar + 1;
        emit Crescut(numar);
    }
}
Excelent! Continuă cu lecția următoare →
Contract.solSolidity
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași cu smart contracts Lecția 14 · Events: jurnalul contractului
Progres 0% 0 din 17
Lecția curentă 14 / 15 Events