Eth1.x: New idea of stateless Ethereum "reGenesis"

This week we will update the tech tree to add some new major milestones for Ethereum 1.x development, these milestones are not a complete implementation of stateless Ethereum, but what we can reasonably achieve in the medium term Target.

One of the most significant updates is Alexey's reGenesis proposal. Although this is far from a standardized update, from a research and development perspective, reGenesis provides a more conservative and feasible path to the ultimate goal of "completely stateless". Complementary to reGenesis in other ways is the Static State Network, which helps propagate state snapshots and history chain data across bittorrent-style DHT-based networks.

At the same time, some goals that are relatively close to us are already preparing for EIP, such as code chunking (code merkleization) and state binary tree. In this article, I will illustrate the progress that has been achieved, and attach links so that readers can drill down into areas of interest.

The Ethereum network has currently destroyed 1,410,200 ETH: Jinse Finance reported that according to Ultrasound data, up to now, the Ethereum network has destroyed a total of 1,41,021,2.46 ETH. Among them, OpenSea destroyed 158562.92 ETH, ETHtransfers destroyed 139532.51 ETH, and UniswapV2 destroyed 117593.91 ETH. Note: Since EIP-1559 was introduced in the upgrade of Ethereum London, the Ethereum network will dynamically adjust the BaseFee of each transaction according to the transaction demand and block size, and this part of the fee will be directly burned and destroyed. [2022/1/10 8:37:29]

Currently, Ethereum uses a hexadecimal Patricia Merkle tree to encode the state, but converting to a binary format will bring significant efficiency improvements, especially in terms of witness size. A complete recoding of the state of Ethereum requires the development of new paradigms, as well as a clear transition strategy. Finally, a decision needs to be made whether to chunk the smart contract code and incorporate this process into the binary tree transition or as a standalone update.

MVIS Partners with CryptoCompare to Launch New Index MVETHV: MV Index Solutions GmbH (MVIS) and CryptoCompare announce a partnership to launch the MVIS CryptoCompare Ethereum VWAP Close Index (MVETHV). MVETHV is an index designed to measure the performance of digital asset portfolios invested in Ethereum, with closing prices based on VWAP hourly prices. (Businesswire) [2021/1/13 16:05:09]

The binary tree concept is a bit simpler than the current hex tree structure. A hexadecimal tree has sixteen possible paths to traverse from the root to a child node, whereas a binary tree has only two. With the renormalization of the state tree, we have the opportunity to address significant inefficiencies in Ethereum’s five-year run. In addition, we also have the opportunity to make state more adaptable to the performance challenges of real-world database coding (mentioned in the previous article on state growth).

The WETH-USDT trading pair on Uniswap has become the most traded trading pair in the year: OKLink released the 2020 on-chain data inventory today. Among them, the WETH-USDT trading pair on Uniswap became the most traded trading pair throughout the year. Before the statistics, the trading pair has generated 1,354,561 transactions. [2020/12/29 15:58:59]

A discussion of the formal binary tree specification and chunking rules can be found at ethresearch.

It's not just the destination of the binary tree paradigm that matters, the journey itself is valuable too! In an ideal transition, there would be no disruption to the network's transaction processing, meaning clients would need to build new binary trees while processing new blocks that appear every fifteen seconds.

The transition strategy that currently looks the most promising is called the "overlay" approach, which is based in part on geth's new snapshot synchronization protocol. In general, new state changes are added to existing hexadecimals in binary paradigm, which means there will be a mix of binary and hexadecimal during the transition. Unaffected states are transitioned to background processing. Once converted, the two layers are merged into a single binary tree.

ETH fell below the $580 mark with an intraday drop of 2.85%: data from Huobi Global shows that ETH fell short-term and fell below the $580 mark. It is now at $579.5, with an intraday drop of 2.85%. The market fluctuates greatly, please do a good job in risk control . [2020/12/1 22:45:43]

It's important to note that client diversity also plays a very important role in the binary translation process. Each client will need to implement its own version of the transition, or rely on other clients to do the transition and then wait for the new tree on the other side.

This requires us to "think twice" and all clients need to work together to test and coordinate the transition. For security reasons, it is possible that the network will need to be temporarily out of service during the transition (e.g. to mine some empty blocks), but it is too early to agree on any concrete plans.

A large portion of the Ethereum state tree consists of smart contract code, accounting for around 1GB of the 50GB state. All witnesses for smart contract interactions must provide the code of their interaction in order to calculate the codeHash, which may generate a lot of additional data.

Market | ETH fluctuates violently. Please pay close attention to the market: Bitfinex data shows that the current ETH price is 1904.36 yuan, which has fallen by more than 19.72 yuan in 15 minutes. The volatility is relatively large. Please pay close attention to the market trend and do a good job of risk control. [2018/8/24]

Code Merkleization aims to divide the contract code into smaller blocks, and then replace the codeHash with another Merkle root. This approach allows us to replace potentially most of the smart contract code in the witness with the reference hash, saving thousands of bytes of witness data.

There are many ways to divide code into chunks. According to the complexity, the simpler way is general chunking (for example, the size of each chunk is 64 bytes), while the more complicated way is static analysis based on Solidity functionId or JUMPDEST instruction. The optimal code chunking strategy ultimately depends on whether it is applicable to real data collected from the main network.

The best place to read about the reGenesis proposal is the explanation given by @mandrigin, and the full proposal submitted by @realLedgerwatch. In summary, reGenesis can basically be described as "blockchain cleaning". The full state will be conceptually divided into "active-ethexc" and "inactive" states. Periodically, the overall "active-ethexc" state is deactivated, and then new transactions create a new active-ethexc state almost from scratch again (hence the name "reGenesis").

If a transaction requires a previous state, a witness is provided, much like the proofs required in stateless Ethereum: a Merkle proof that a state change is consistent with some inactive state. If a transaction requires the "inactive" part of the state, it will automatically turn it into the "active-ethexc" state (whether the transaction is successful or not), and this part will be left until the next reGenesis occurs.

One advantage of this is that it creates some economic constraints on using state without actually removing any state. Second, if the transaction sender is blindly repeatedly trying to transact, a witness cannot be generated.

Regarding the significance of reGenesis, it makes Ethereum take a big step towards the ultimate stateless goal, and avoids the biggest challenge to achieve statelessness, that is, how to calculate the witness gas during EVM execution. At the same time, it also enables a certain version of the transaction witness to be propagated in the network, allowing lighter clients and dapp developers to have more opportunities to become familiar with the stateless paradigm and witness generation.

"True" statelessness after reGenesis is a matter of degree: Stateless Ethereum is really just reGenesis after each block.

From the beginning, the optimization of the network protocol was only a "side task" in the technology tree, but as reGenesis entered the territory of stateless Ethereum, it became an important task to explore alternative network primitives for sharing Ethereum chain data (including state). main mission. The current network protocol of Ethereum is a whole, but in fact there are multiple types of data that can be shared through different "sub-networks", and these "sub-networks" can meet different needs.

When we discussed this topic in the stateless conference earlier, we called it the "three networks", and the DHT-based network can more efficiently serve data types that do not change frequently. With the introduction of reGenesis, the "inactive" state can be included in this kind of infrequently changing data, and theoretically it can also be applied to the bitstream swarm network, rather than the current one-by-one broadcast by the full node.

Since the last reGenesis, a network that propagates a constant state across the network is a static state network, which can be extended based on the new Discovery v5.1 specification in the devp2p library (Ethereum network protocol).

Similar to Merry-go-Round sync and the more mature SNAP protocol, it can be used to synchronize the active-ethexc state, which is an important step towards a fully distributed dynamic state network, enabling the client to quickly synchronize the complete state.

Tags：

AAVE