Gas: cât costă fiecare operație
Fiecare instrucțiune executată de EVM are un preț în gas, iar tranzacția plătește gas-ul consumat în ether. În această lecție vezi de ce scrierea în storage este cea mai scumpă operație, ce sunt gas limit și gas price și cum măsori costul funcțiilor tale.
De ce există gas
Mii de noduri execută fiecare tranzacție. Dacă execuția ar fi gratuită, oricine ar putea trimite o buclă infinită și ar bloca rețeaua. Soluția Ethereum: fiecare operație are un cost fix, măsurat în gas, iar cel care trimite tranzacția plătește. O buclă infinită doar își consumă gas-ul până se oprește.
Gândește-te la gas ca la benzina unei mașini: distanța (munca) se măsoară în litri consumați, iar prețul litrului (gas price) se schimbă de la o zi la alta. Comisionul final este litri × preț.
Ce costă mult și ce costă puțin
| Operație | Gas (aprox.) | De ce |
|---|---|---|
| Calcule (ADD, MUL, comparații) | 3–5 | doar procesor, pe stivă |
| Citire din storage (SLOAD) | 2 100 rece, 100 caldă | acces la starea salvată de toate nodurile |
| Scriere nouă în storage (0 → x) | 22 100 | fiecare nod trebuie să păstreze slotul pentru totdeauna |
| Modificare în storage (x → y) | 5 000 | slotul exista deja |
| Eveniment (LOG) | ~375 + 8 / octet | se salvează în receipt, nu în stare |
| Orice tranzacție | 21 000 de bază | semnătura, nonce-ul, transferul |
Regula de aur: storage-ul este scump, calculele sunt ieftine. Un contract eficient citește și scrie storage-ul cât mai rar.
Când readuci un slot la 0 (de exemplu ștergi o valoare), primești înapoi o parte din gas (refund), pentru că nodurile pot elibera spațiul. Refund-ul este limitat la o cincime din gas-ul tranzacției.
Măsoară singur
gasFolosit(promisiune) trimite tranzacția și îți întoarce gas-ul consumat (ca BigInt). Comparăm prima scriere într-o variabilă cu a doua:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Cutie {
uint public valoare;
function scrie(uint v) public {
valoare = v;
}
function nimic() public {}
}const cutie = await deploy("Cutie");
const prima = await gasFolosit(cutie.scrie(5)); // 0 -> 5
const aDoua = await gasFolosit(cutie.scrie(7)); // 5 -> 7
const goala = await gasFolosit(cutie.nimic()); // nu scrie nimic
console.log("Prima scriere > a doua:", prima > aDoua);
console.log("Diferența peste 15 000:", prima - aDoua > 15000n);
console.log("Funcția goală costă peste 21 000:", goala > 21000n);Prima scriere > a doua: true Diferența peste 15 000: true Funcția goală costă peste 21 000: true
Diferența exactă este de 17 100 gas: 22 100 (slot nou) minus 5 000 (slot existent). Chiar și o funcție care nu face nimic costă puțin peste 21 000: costul de bază al tranzacției plus câteva instrucțiuni care aleg funcția.
Gas-ul exact depinde de compilator și de setările lui. În teste compară valori (prima > aDoua) în loc să scrii numere fixe.
Gas price, comision și gas limit
- Gas used: câtă muncă a făcut EVM (se știe doar după execuție).
- Gas price: cât plătești pentru fiecare unitate de gas, în gwei. După EIP-1559 este format din base fee (stabilit de rețea și ars) și priority fee (bacșișul validatorului).
- Gas limit: maximul pe care îl accepți. Portofelele îl estimează automat; dacă execuția îl depășește, tranzacția eșuează cu „out of gas”.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Cutie {
uint public valoare;
function scrie(uint v) public {
valoare = v;
}
function nimic() public {}
}const cutie = await deploy("Cutie");
const tx = await cutie.scrie(5);
const rc = await tx.wait();
const pret = (await provider.getFeeData()).gasPrice;
console.log("Preț gas (gwei):", ethers.formatUnits(pret, "gwei"));
console.log("Comision = gas × preț:", rc.fee === rc.gasUsed * pret);
const t2 = await ana.sendTransaction({ to: bogdan.address, value: ethers.parseEther("1") });
console.log("Transfer simplu de ETH:", (await t2.wait()).gasUsed, "gas");Preț gas (gwei): 1.0 Comision = gas × preț: true Transfer simplu de ETH: 21000 gas
Pe blockchain-ul din curs prețul este fix, 1 gwei. Pe mainnet variază după cât de aglomerată este rețeaua: același transfer de 21 000 gas poate costa de câteva ori mai mult în orele de vârf.
Când gas-ul nu ajunge
O funcție cu o buclă care scrie în storage consumă gas proporțional cu numărul de pași. Dacă îi dai un gas limit prea mic, se oprește la jumătate:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Lista {
uint[] public numere;
function adaugaMulte(uint n) public {
for (uint i = 0; i < n; i++) {
numere.push(i);
}
}
}const lista = await deploy("Lista");
try {
const tx = await lista.adaugaMulte(50, { gasLimit: 100000 });
await tx.wait();
} catch (e) {
console.log("Eșuat:", motivRevert(e));
}Eșuat: gas epuizat (out of gas)
Toate cele câteva elemente adăugate înainte de oprire sunt anulate, iar gas-ul consumat până acolo se plătește. De aceea buclele peste liste care cresc fără limită sunt periculoase: într-o zi pot depăși limita blocului (30 000 000 de gas) și funcția devine imposibil de apelat.
Greșeli frecvente și exemple reale
- Scrieri inutile în storage: dacă o valoare se poate calcula, nu o salva.
- Bucle fără limită peste liste din storage: costul crește la fiecare element nou.
- Gas limit setat manual prea mic: plătești pentru o tranzacție eșuată.
La lansări populare, gas price a urcat la sute de gwei, iar unele tranzacții eșuate au costat zeci de dolari.
Arbitrum sau Base execută aceleași contracte cu comisioane mult mai mici, grupând tranzacțiile.
Arată în timp real prețul gas-ului și cât costă un transfer sau un schimb.
Scrie contractul Depozit cu variabila publică valoare (uint) și funcția scrie(uint v), care salvează valoarea primită. Scriptul lecției măsoară gas-ul pentru scrie(5) (prima scriere, 0 → 5) și pentru scrie(7) (a doua, 5 → 7) și afișează dacă prima a costat mai mult, apoi valoarea finală.
- Declară uint public valoare;.
- Scrie funcția scrie(uint v) de tip public.
- În funcție, salvează v în valoare.
Soluția exercițiului
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Depozit {
uint public valoare;
function scrie(uint v) public {
valoare = v;
}
} 