...
Eroare Solidity · Importuri și erorile OpenZeppelin

VM Exception while processing transaction: reverted with custom error 'ERC20InvalidReceiver("0x0000000000000000000000000000000000000000")'

Pe scurt

Ai încercat să trimiți sau să emiți tokeni către address(0). ERC20 din OpenZeppelin 5 refuză asta: pentru ardere există _burn, iar la _mint destinatarul trebuie să fie o adresă reală. Verifică adresa folosită (de multe ori o variabilă încă nesetată) sau înlocuiește transferul către zero cu _burn.

Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

Ce înseamnă

În ERC-20, tokenii ajunși la address(0) ar dispărea fără ca totalSupply să scadă, așa că OpenZeppelin 5 refuză orice transfer sau emitere către adresa zero cu eroarea custom ERC20InvalidReceiver(address(0)). Pentru ardere există funcția internă _burn(cont, suma), care scade și soldul, și oferta totală.

Apare în trei situații tipice:

  • o funcție de ardere scrisă ca transfer către zero (transfer(address(0), suma), obicei din tutoriale vechi);
  • _mint în constructor către o variabilă de stare care încă nu a fost setată (de exemplu trezoreria, setată pe linia următoare);
  • un script care trimite tokeni către ethers.ZeroAddress sau o adresă necompletată.

Perechea ei, ERC20InvalidSender(address(0)), apare când _burn sau _transfer primesc adresa zero ca expeditor.

De ce apare: cauzele frecvente

1Ardere scrisă ca transfer către zero

Greșit
SOLIDITY
function arde(uint256 suma) external {
    transfer(address(0), suma);
}
Corect
SOLIDITY
function arde(uint256 suma) external {
    _burn(msg.sender, suma);
}

_burn scade soldul și totalSupply; transferul către zero e refuzat.

2Emitere către o variabilă nesetată

Greșit
SOLIDITY
constructor(address t) ERC20("Moneda", "MON") {
    _mint(trezorerie, 1000e18);
    trezorerie = t;
}
Corect
SOLIDITY
constructor(address t) ERC20("Moneda", "MON") {
    trezorerie = t;
    _mint(trezorerie, 1000e18);
}

La momentul lui _mint, trezorerie era încă address(0).

3Adresă goală în script

Greșit
SOLIDITY
await token.transfer(ethers.ZeroAddress, eth("10"));
Corect
SOLIDITY
await token.transfer(bogdan.address, eth("10"));

Verifică adresele înainte de transfer.

Repară tu

Repară eroarea, direct în pagină

Tokenul Voucher emite 100 VCH anei la publicare, iar funcția arde ar trebui să distrugă tokenii folosiți. Funcția face un transfer către address(0) și dă ERC20InvalidReceiver(0x0000000000000000000000000000000000000000). Rescrie-o ca să ardă tokenii corect. Scriptul arde 30 VCH și afișează soldul anei și oferta totală.

Codul care dă eroarea
SOLIDITY
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {ERC20} from "./ERC20.sol";

contract Voucher is ERC20 {
    constructor() ERC20("Voucher", "VCH") {
        _mint(msg.sender, 100 ether);
    }

    function arde(uint256 suma) external {
        transfer(address(0), suma);
    }
}
După reparație, programul afișează
Ana: 70.0 VCH
Ofertă totală: 70.0 VCH
Indiciu

ERC20 are funcția internă _burn(cont, suma).

Alte forme ale mesajului

  • execution reverted: custom error 'ERC20InvalidReceiver(0x0000000000000000000000000000000000000000)'
  • ERC20: transfer to the zero address
  • ERC20: mint to the zero address
  • VM Exception while processing transaction: reverted with custom error 'ERC20InvalidSender("0x0000000000000000000000000000000000000000")'

Cum o eviți pe viitor

  • Pentru ardere folosește _burn (sau ERC20Burnable), nu transferuri către zero.
  • În constructor, setează întâi variabilele de stare, apoi folosește-le.
  • Validează adresele primite ca parametri: require(cont != address(0), "Adresa invalida").
  • Testează funcțiile cu adresa zero, ca să vezi că sunt respinse cu un mesaj clar.

Întrebări frecvente

Tokenii trimiși la adresa zero dispăreau înainte?

În unele implementări vechi, da: ajungeau la o adresă de la care nimeni nu-i poate muta, dar totalSupply rămânea neschimbat. OpenZeppelin a interzis asta tocmai ca să nu existe tokeni „pierduți” care încă apar în ofertă.

Pot arde tokenii altcuiva?

Doar cu permisiune: în ERC20Burnable, burnFrom(cont, suma) consumă allowance-ul dat de acel cont, la fel ca transferFrom.

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.