Vitalik’s latest article: What do you need to remove in the Purge phase of Ethereum

Author: Vitalik, founder of Ethereum; Translation: Shan Ouba, Bitchain Vision Realm

One of the unknown EIPs in the recent DENCUN hard split fork is the EIP-6780, which deletes most of the function of the operating code SelfDestruct.

This EIP is a key example of the Ethereum Agreement Development.By eliminating complexity and addingNewSecurity guarantee to simplify the efforts of the agreement.This is an important part of the “Purge” I call: streamlined Ethereum and cleared technical debt projects.There will be more EIP with a similar spirit, soIt is worth understanding how the EIP-6780 goals, and which other EIPs may be cleared in Purge in the future.

How does EIP-6780 simplify the Ethereum agreement?

The EIP-6780 reduces the function of the operation code SelfDestruct. It will destroy the contract and clear its code and storage. Therefore, it is effective only when the contract is created during the same transaction.This itself has not decreasedspecificationThe complexity.However, it does improve by introducing two new invariable variablesaccomplishThe

1. After EIP-6780, the number of storage slots that can be edited in a single block is maximum (roughly: Gas Limit / 5000).

2. If the contract has non -empty code at the beginning of the transaction or block, it will have the same code at the end of the transaction or the end of the block.

Previously, these invariant variables were not true:

1,SelfDestructA contract with a large amount of storage slot can clear the unlimited amount of storage slot in a single block.This will make the realization of the Verkle tree more difficult and make the implementation of the Ethereum client more complicated, because they need additional code to effectively handle this special situation.

2. The code of the contract can be changed from non -empty to emptiness through SelfDestruct. In fact, the contract can even be re -created immediately with different code.This makes it difficult for transactions in account abstract wallets to use code libraries without being easily attacked by DOS.

Now, these are not variablesAllTRUE makes it easier to build an Ethereum client and other types of infrastructure.A few years later, I hope that the future EIP will be able to complete this work andSelfDestructCompletely eliminated.

Which other “Purges” are ongoing?

Geth has recently deleted thousands of lines of code and deleted support for the Pre-Merge Pow network.
This EIP officially reflects such a fact: we no longer need code to worry about “empty accounts” (see: EIP-161, it introduces this concept as part of the Shanghai DOS attack repair)
The storage window in Dencun is 18 days, which means that Ethereum nodes only need about 50 GB to store BLOB data, and this number will not increase over time over time.

The first two significantly improved the experience of client developers.The latter has significantly improved the life of node operators.

What other things that may require Purge?

Preset (Precompiles)

Pre -compilation is the Ethereum contract. It does not have an EVM code, but has logic that must be directly implemented by the client.This idea is that pre -compilation can be used to realize complex formats that cannot be effectively implemented in EVM.

Today, the pre-compilation is very successful, especially the app-based application based on the oval curve pre-compilation.However, there are other pre -compilation that rarely uses:

Ripemd-160: The introduction of the hash function is to support better compatibility with Bitcoin
Identity: Back to pre -compilation of the same output as the input
Blake2: The introduction of the hash function is to support better compatibility with Zcash
ModexpIntroduce a very large mold power to support RSA -based encryption

Facts have proved that the needs of these pre -compilationFar awayBelow than expected.IdentityIt is widely used because it is the easiest way to copy data, but since Dencun, the operating code Mcopy has replaced it.Unfortunately, these pre-compilation is a huge source of consensus errors, and it is also a huge source of pain achieved by the new EVM, including the ZK-SNARK circuit, formal verification of friendly realization.

There are two ways to delete these pre -compilation:

Just delete pre -compilation, for example.EIP-7266 deletes Blake2.This is simple, but it will destroy any application that is still using it.
Replace the pre -compilation to the EVM code block that performs the same operation (although it will inevitably generate higher GAS costs), for example.This draft EIP is done for pre -compilation of identity.This is more difficult, but it will almost definitely not destroy the application using it (unless there are very few cases, the cost of the GAS of the new EVM code exceeds that the input block is limited)

Historical block (EIP-4444)

Today, every Ethereum node is expected to permanently store all historical blocks.For a long time, people have always believed that this is a very wasteful method, and because of high storage requirements, it has become unnecessary to run the Ethereum node.In Dencun, we introduced Blob, which only needs to store about 18 days.After using EIP-4444, after a period of time, the Ethereum block will also be deleted from the default Ethereum node.

One key problem to be solved is: If the old historical records are not stored by each node, then what to useComeWhat about it?In fact, large entities such as block browsers will do so.However, it is also possible to store and pass the P2P protocol to store and pass the information, and it is not difficult, which is more optimized for tasks.

The Ethereum blockchain is permanent, but it is required that each node to store all data forever is a very “overkill” way to achieve this permanent.

One way is to target the simple point -point Torrent network for the old history.The other is a clearer agreement for the use of Ethereum, such as the portal network.

Or, the factor format:

Reducing the storage of the Ethereum node can greatly increase the number of people willing to be nodes.EIP-4444 can also reduce node synchronization time, which also simplifies the workflow of many node operators.Therefore, EIP-4444 can greatly improve the decentralization of Ethereum nodes.Potentially, if each node is defaults to a small part of historical records, we can even store a copy of each specific historical record on the Internet like today.

Log reform

Quote this EIP draft:

The original introduction of the log was to enable the application to record information about events on the chain so that decentralized applications (DAPP) can easily query these information.Using a BLOOM filter, DAPP will be able to quickly browse historical records, identify several blocks containing logs related to its application, and then quickly identify which single transactions have the required logs.

In fact, this mechanism is too slow.Almost all DAPPs that visit historical records are not in the end through RPC calls of Ethereum nodes (and even remote hosting nodes), but through centralized additional protocols.

What can we do?We can delete the Bloom filter and simplifyLogOperation code, this wayitWhat you do is to create a value that put the hash into the state.Then, we can build a separate protocol, using ZK-SNARK and incremental increased calculation (IVC) to generate the correct “log tree”, it indicates that all given logs that are easy to search for the search table that is easy to search fortopicAnd if you need logs and applications you want to be decentralized, you can use these separate protocols.

Turn to SSZ

Today, most of the block structures (including transactions and receipts) of Ethereum still use an outdated format based on RLP and Merkle Patricia trees for storage.This makes it unnecessary difficulties to develop applications using this data.

Ethereum consensus layer has shifted to cleaner and more efficient Simpleserialize (SSZ):

Source: https://eth2book.info/altair/part2/building_blocks/merkleization/

However, we still need to complete the conversion and move the execution layer to the same structure.

The main advantages of SSZ include:

Specifications are simpler and clear
Compared with the current hexagonal Merkle Patricia tree, in most cases, the length of Merkle’s proof has been shortened by 4 times
Compared with the worst and worst case, the length of Merkle’s proof is bounded (for example, the contract code or long receipt output)
No need to achieve complex bit operation code (RLP needs)
For ZK-SNARK use cases, the existing implementation of the existing implementation of the binary Merkle tree can be reused

Today, there are three types of encrypted data structures in Ethereum: SHA256 binary tree, SHA3 RLP hash list, and hexadecimal Patricia tree.Once we complete the transition to SSZ, we will have only two: Sha256 binary tree and Verkle tree.In the long run, once we do well in the Snarking hash enough, we are likely to use the binary Merkle tree to replace the SHA256 binary tree and Verkle with the binary Merkle tree that uses Snark’s friendly hash (a kind of encrypted data structure for all Ethereum).Tree.