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
- To burn ETH, contracts use a workaround by sending it to an unrecoverable address such as the zero address.
- Indexers and tracking tools find it hard to distinguish which transfers are actual burns.
- There remains a risk that ETH treated as burned is unexpectedly recovered.
After EIP-7775
- A contract directly burns ETH from its own balance with a single BURN opcode.
- Burning becomes an explicit action, letting indexers and tools tally it accurately.
- Reduces mistakes where ETH marked as burned later comes back to life.
Who is affected
- Smart contract developers: Burning can be implemented with a standard opcode instead of workaround transfers, and native token accounting inside contracts becomes clearer.
- Indexers and block explorers: Because burning shows up as a distinct opcode, tracking and aggregating token movement becomes simpler.
- Client teams: A new opcode must be implemented, and a new concept must be added to the Yellow Paper.
- L2: The original text mentions this opcode could be useful when sending ETH back to L1.
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.