Warning: Return value of low-level calls not used.
Ai făcut un call (sau delegatecall) fără să verifici dacă a reușit. Un call eșuat nu oprește tranzacția: întoarce false, iar codul tău merge mai departe ca și cum plata ar fi plecat. Preia rezultatul și verifică-l: (bool ok, ) = ...; require(ok, "Plata esuata");
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Apelurile de nivel jos (call, delegatecall, staticcall, send) nu dau revert când apelul eșuează. Ele întorc false și lasă decizia la tine. Dacă ignori rezultatul, contractul continuă: marchează o factură ca plătită, scade un sold, emite un eveniment, deși banii n-au plecat nicăieri.
Avertismentul compilatorului semnalează exact acest tipar periculos. Este una dintre vulnerabilitățile clasice din auditurile de smart contracts („unchecked return value”).
Un call poate eșua de exemplu când destinatarul e un contract fără receive / fallback payable, când acesta dă revert intenționat, când rămâne fără gas sau când contractul tău nu are destul ether. Spre deosebire de call, transfer și apelurile normale prin interfață (token.transfer(...)) propagă singure revert-ul.
De ce apare: cauzele frecvente
1Plată cu call fără verificare
payable(furnizor).call{value: suma}("");
platit[furnizor] = true;(bool ok, ) = payable(furnizor).call{value: suma}("");
require(ok, "Plata esuata");
platit[furnizor] = true;Cu require(ok), o plată eșuată anulează toată tranzacția, inclusiv marcarea ca plătit.
2send fără verificare
payable(castigator).send(premiu);(bool ok, ) = payable(castigator).call{value: premiu}("");
require(ok, "Premiu netrimis");send întoarce false la eșec, la fel ca call. Folosește call și verifică rezultatul.
3Plăți către mulți destinatari într-o buclă
for (uint256 i = 0; i < castigatori.length; i++) {
payable(castigatori[i]).call{value: premiu}("");
}for (uint256 i = 0; i < castigatori.length; i++) {
deRetras[castigatori[i]] += premiu;
}
// fiecare apelează retrage()Ca un destinatar care respinge plata să nu blocheze sau să păcălească bucla, folosește modelul retragerii (pull payments).
Repară eroarea, direct în pagină
Contractul Plati se compilează cu avertismentul Return value of low-level calls not used. Funcția plateste trimite bani cu call, dar nu verifică rezultatul: când furnizorul este un contract care nu acceptă ether, plata eșuează, iar factura e marcată totuși plătită. Preia rezultatul lui call și respinge tranzacția cu mesajul "Plata esuata" dacă a eșuat. Scriptul plătește un contract fără receive și apoi pe bogdan.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Plati {
mapping(address => bool) public platit;
constructor() payable {}
function plateste(address furnizor, uint256 suma) external {
payable(furnizor).call{value: suma}("");
platit[furnizor] = true;
}
}Plată către Furnizor: Plata esuata | marcat plătit: false Bogdan plătit: true | sold contract: 0.6 ETH
Indiciu
(bool ok, ) = ... și apoi require(ok, "Plata esuata");, înainte să marchezi factura.
Reparația
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Plati {
mapping(address => bool) public platit;
constructor() payable {}
function plateste(address furnizor, uint256 suma) external {
(bool ok, ) = payable(furnizor).call{value: suma}("");
require(ok, "Plata esuata");
platit[furnizor] = true;
}
}De ce merge
call nu oprește tranzacția când destinatarul respinge ether-ul, ci întoarce false. Fără verificare, contractul marca furnizorul ca plătit, deși banii nu plecaseră. Cu (bool ok, ) = ... și require(ok, "Plata esuata"), plata eșuată anulează tot, deci platit rămâne false, iar plata către bogdan, un cont obișnuit, reușește. În contract rămân 0,6 ETH.
Alte forme ale mesajului
Warning: Failure condition of 'send' ignored. Consider using 'transfer' instead.
Cum o eviți pe viitor
- Nu lăsa niciodată un
callfără(bool ok, ) = ...șirequire(ok, ...). - Tratează avertismentele compilatorului despre apelurile de nivel jos ca pe erori.
- Pentru plăți către mulți oameni, folosește modelul retragerii: fiecare își cere singur banii.
- Testează și cazul în care destinatarul este un contract care respinge ether.
Întrebări frecvente
De ce call nu dă revert singur, ca transfer?
Pentru că e un instrument de nivel jos, care îți lasă ție decizia: uneori vrei să continui chiar dacă un apel a eșuat (de exemplu, plătești pe ceilalți și îl notezi pe cel care a respins). De aceea trebuie să verifici rezultatul de fiecare dată.
token.transfer(...) are aceeași problemă?
Apelul prin interfață propagă revert-ul, dar unii tokeni vechi întorc false în loc să dea revert. De aceea se verifică și rezultatul (require(token.transfer(...))) sau se folosește SafeERC20 din OpenZeppelin.
Erori înrudite
TypeError: Different number of components on the left hand side (1) than on the right hand side (2). În stânga lui = ai mai puține (sau mai multe) variabile decât valori întoarse în dreapta. Tipic la call, care întoarce două valori: scrie (bool ok, ) = adresa.call{value: suma}(""); cu virgula care sare peste a doua. TypeError: "send" and "transfer" are only available for objects of type "address payable", not "address". Apelezi transfer() sau send() pe o adresă simplă, de exemplu msg.sender.transfer(suma). În 0.8 trebuie payable(msg.sender).transfer(suma) sau, varianta recomandată, (bool ok, ) = payable(msg.sender).call{value: suma}(""); require(ok); VM Exception while processing transaction: reverted with reason string 'Plata insuficienta' Un require (sau revert) din contract a oprit tranzacția, iar textul dintre ghilimele este chiar mesajul scris în cod. Caută mesajul în contract, vezi ce condiție verifică și află de ce n-a fost îndeplinită: argumente greșite, alt cont, prea puțin ether sau o condiție scrisă greșit. Î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.
