EIP-7775 Native ETH Burn: the BURN Opcode (BURN opcode)

No call decision · EVM & execution · EIP status Stagnant · created 2024-09-30

Adds a BURN (0xFC) opcode to the EVM so that smart contracts can explicitly burn the native ETH held at their own address.

Why it is needed

Ethereum currently has no official way to destroy ETH. Contracts that want to burn ETH, such as the BeaconDepositContract, have had to fake a burn by sending ETH to an address no one can withdraw from or to a contract with no withdrawal function. This approach is not only inefficient but also confusing for indexers and tooling that track token movement. There is also a risk that ETH marked as burned ends up being unexpectedly recovered, which can lead to contract vulnerabilities. A dedicated BURN opcode standardizes burning into one clear, consistent method. The original text notes it could also be useful for L2s sending ETH back to L1, or for other EVM-based L1 chains that want to use this function in their own cryptoeconomic designs.

What changes

Today

After EIP-7775

Who is affected

In depth

Basic behavior specification

The BURN opcode is assigned 0xFC. It pops one 32-byte word from the top of the stack, interprets it as a uint256 burn amount, retrieves the address of the current EVM execution context, and checks that address's balance. If the burn amount exceeds the balance, it MUST revert; if the burn amount is 0, it MUST NOT revert. If the conditions pass, the burn amount is subtracted from the current address's native ETH balance. The burn target is always the address of the current context; it cannot burn the balance of any other arbitrary address.

Behavior under DELEGATECALL, CALLCODE, and STATICCALL

If BURN executes within a DELEGATECALL or CALLCODE context, the contract whose balance is manipulated is the contract that issued the DELEGATECALL or CALLCODE instruction. In other words, the called code ends up burning the calling contract's ETH. If BURN executes within a STATICCALL context, that call MUST revert, since it is a state-changing opcode and is not allowed in read-only calls.

Gas cost

The base gas cost is 100. The dynamic gas cost falls into three cases: 0 if the value to burn is 0, 0 if the account does not exist or the account balance is 0, and 2800 otherwise. The total gas cost is the sum of the base and dynamic costs. The original pseudocode shows the flow consuming the base 100 gas first, then consuming an additional 2800 gas only when the balance is actually deducted, with a comment noting that 'warm' gas is charged at this point because account existence has already been confirmed.

Design rationale: why a dedicated opcode

The original Rationale section points out that the existing burning convention, sending ETH to the zero address or to a contract with no withdrawal function, is inefficient and confuses tracking tools like indexers. The benefits cited are providing a standardized burn method, improving native token accounting within contracts, and reducing the possibility of exploits arising from 'burned' tokens being unexpectedly recovered. The drawbacks cited are that it does not solve the problem of unrecoverable ETH already locked in existing contracts, that it requires new client code, and that it requires adding a new concept to the Yellow Paper.

Security considerations

The original text notes that combining this with DELEGATECALL opens up potential for misuse. In a DELEGATECALL context, the calling contract's balance is what gets burned, so delegating a call to untrusted code could result in your own ETH being burned. The original text only states that this 'needs discussion' and does not offer a concrete mitigation.

Progress status and activation conditions

Since this change adds a new opcode, it must be activated through a scheduled hard fork. Test cases and a reference implementation are still marked TODO and left empty in the original text. This EIP's status is Stagnant; it is not currently under active development and there is no guarantee its content will be adopted as is. There is no record of a decision to include it in a fork from core dev calls.

Original EIP · ← EIPs