Where does burnt ether go?

Question

When Ethereum burns ether by taking it out of circulation, what exactly happens? Where does this ether go?

Answer 1

It simply disappears. It's a bit similar to burning fiat money, literally: if you burn a $10 bill properly, there's nothing of value left and that amount of value is taken out of circulation.

Technically it's just decreasing some numbers. So if the amount of Ether in circulation is X, after burning Y amount of Ether there's X - Y amount in circulation anymore.

Answer 2

Burnt tokens generally go to the zero account: 0x0000000000000000000000000000000000000000. This is the null address.

If you look at the 'from' field in newly minted tokens and contracts, it's also the zero account. It's not a real address

Answer 3

Burned tokens are just subtracted from total amount of tokens i.e from _totalSupply.

You can check openzeppelin github

Burning is done as:

    _balances[account] = accountBalance - amount; 
    // account -> who want to burn
    // amount -> How much to burn
    _totalSupply -= amount;

_burn function:

function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

Answer 4

burnt tokens are actually sent to an account address or contract address that cannot be retrieved again.

Openzeppeling/ ERC20Burnable.sol

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

This will call ERC20._burn

function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }
     

_burn function just updates the state of account balance and total supply of the ERC20 token. this is what burning is just updating state balances.

Ethereum burning mechanism gets updated bu EIP proposals. I believe latest was eip-1559. With this network fees are burnt. So all other crypto platform's when they have a transaction part of the transaction fee is burnt. Their wallets automatically burn

You can monitor burning here: https://etherchain.org/burn