...
Eroare Solidity · Ether: payable, transfer și call

Warning: Return value of low-level calls not used.

Pe scurt

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

Greșit
SOLIDITY
payable(furnizor).call{value: suma}("");
platit[furnizor] = true;
Corect
SOLIDITY
(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

Greșit
SOLIDITY
payable(castigator).send(premiu);
Corect
SOLIDITY
(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ă

Greșit
SOLIDITY
for (uint256 i = 0; i < castigatori.length; i++) {
    payable(castigatori[i]).call{value: premiu}("");
}
Corect
SOLIDITY
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ă tu

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.

Codul care dă eroarea
SOLIDITY
// 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;
    }
}
După reparație, programul afișează
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.

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 call fără (bool ok, ) = ... și require(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

← Toate erorile Solidity

Tudor Andrei Dumitrescu
Cine a explicat eroarea

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. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.