header-langage
简体中文
English
Tiếng Việt
Scan to Download the APP
Partnered With:

ETH 2.0 is a form of rollup

Read this article in 11 Minutes
The path to a fully functional ETH 2.0 has never been clearer.
Original title: "Viewpoint | ETH 2.0 is a form of rollup"
Original source: Ethereum enthusiasts


As we transition to a new scaling paradigm, it's good practice to look back at old ones that were abandoned.


This article aims to convince the reader that the "rollup-centric" approach does not deviate from sharding and is expected to build support for the entire (hypothetical) A more intuitive understanding of the system.


Definition of Optimistic Rollup


< p>

For the purposes of this article, we first detail the simplest Optimistic Rollup (ORU) implementation.


ORU needs to have the following characteristics:


All transactions Commit data to chain

Submit state root to chain

Assume state root is correct

Some nodes are responsible for verifying ORU state transitions

There is an on-chain fraud proof execution program that can undo invalid state transitions


Why fragmentation is not feasible


Before proving that ETH 2.0 sharding is just a complex ORU system, let's explore why the native sharding system is not a secure scalability solution. The reason behind this is not particularly intuitive.


Prove the security of fragmentation from a mathematical point of view


Assume one There are 16384 validators on the blockchain and 64 shard chains, each shard chain is verified by a committee of 128 validators. Committee member elections are unpredictable: after each slot, all committees are disbanded and 64 committees are randomly re-elected from all validators, so each validator does not know which committees other validators are on. Assuming that a block needs to be approved by 2/3 members of the committee (that is, not less than 86 members) before it can be added to the shard chain, this means that 1/3 of the malicious validators are included in all validators. In this case, the probability of selecting a malicious committee randomly is:




Note that we can scale this parameter up or down by adjusting the size of the committee to achieve the desired level of security.


Due to the extremely low probability of electing a malicious committee and the reverse incentive for not acting as a validator, this sharding system should inherit its non-sharding coordination system (it's non-sharded coordinator) security and activity guarantee. However, like most systems in the real world, achieving this is not trivial. Since committee members are selected in advance, malicious actors have the opportunity to bribe rational actors. More bribery would occur if a mapping from validator public keys to IP addresses could be easily created. Furthermore, in a permissionless system, verifiable voting is inherently unable to prevent bribery. In summary, the actual security of sharding is at least an order of magnitude lower than the theoretical one.


Same as Plasma, sharding also has data availability issues


Although sharding is safe The security is lower than the overall protocol, but we can still ensure its security, that is, use fraud proofs to reverse invalid state transitions. However, if we do not introduce additional design for the simple sharding chain we imagined, then malicious verifiers can completely withhold the data and not release it, so that others do not have enough data to generate fraud proofs. Next, we will explain how to implement this attack.


Suppose there is a simple sharded blockchain B with two shard chains X and Y on it. Blockchain B runs a traditional Byzantine Fault Tolerant consensus algorithm in two committees to help run shards X and Y, Cx  and Cy respectively. Each block on B contains two threshold signatures, that is, the witness of 2/3 members of the two committees of Cx  and Cy  to the state root of the current block of the respective shard chain.


Assuming that each shard chain has the same amount of data and transaction processing per second as a non-shard system, the introduction of shard chains should provide approximately twice the throughput. In the optimistic case, it does.


Now, let's launch a data unavailability attack on B. Suppose a malicious entity is able to force 2/3 + 1 members of Cx  to sign an invalid state root and not disclose the input data of the corresponding block. This invalid state root will then be included in the next block that will be added to B. At this time, there is no reasonable mechanism to return B to a valid state. We can give some examples of mechanisms:


The remaining 1/3 of Cx  - 1 member can alert on B that data is unavailable. Unfortunately, this is not an attributable error (Translator's Note: It is impossible to determine whether the attacker withheld the block, or some people did not receive it due to poor network, or even bit others when they received it), Therefore B cannot determine which party is doing the evil. (If some members are recklessly punished) A malicious minority may use this to launch a zero-cost DDOS attack.


Other nodes in the network can alert that data is unavailable. But they probably couldn't, because during the time of the error, only members of Cx  were keeping tabs on the time.


It's up to the whole community to spot the bug and step in proactively to roll B back to the latest valid state. This mode of handling is obviously bad.


Execute a mass exit mechanism similar to Plasma, and exit from X to B in batches will have related negative effects.


As with Plasma, the real issue here is data availability.


Safely increase data availability


I hope the above analysis can make you understand a truth: we should first focus on expanding the data availability of the base layer. Otherwise, the system will still suffer from data unavailability attacks.


Traditionally, improving the data throughput on the blockchain requires the minimum hardware/ Bandwidth requirements reach social consensus  - come up with an acceptable block size. Recent research by Mustafa Al-Bassam and Vitalik Buterin provides a probabilistic mechanism to ensure data availability. M. Yu et al. further extended the research, proposed the concept of Coded Merkle Tree accumulator, and gave the optimal order index (order-optimal metrics).


The above mechanism mainly relaxes the requirement for participants in the network to download all data. Vitalik's proposal is to let participants in the network randomly select a small part of the data in the block to verify to ensure that the block proposer has disclosed the data. The risk is that a block proposer only needs to hide a small amount of data to mount a data unavailability attack. Therefore, participants must sample blocks multiple times to build sufficient confidence in the availability of blocks. In order to reduce the number of samples, Vitalik proposed to use two-dimensional Reed-Solomon coding to encode the block data.


In this structure, the block is divided into N shares, and then encoded to generate M shares, Blocks can be reconstructed as long as they have any N shares in M. Assuming 2N=M, the block proposer needs to affect 1/2 of the block data in order to successfully launch a data unavailable attack. Coded Merkle Tree adopts a similar structure, but uses O(b) decoding cost and O(1) hash commitment instead of O(b1.5) decoding cost and O(< path stroke-width="0" d="M73 647Q73 657 77 670T89 683Q90 683 161 688T234 694Q246 694 246 685T212 542Q204 508 195 472T180 418L176 399 Q176 396 182 402Q231 442 283 442Q345 442 383 396T422 280Q422 169 343 79T173 -11Q123 -11 82 27T40 150V159Q40 180 48 217T97 414Q147 611 147 623T109 637Q104 637 101 637H96Q86 637 83 637T76 640T73 647ZM336 325V331Q336 405 275 405Q258 405 240 397T207 376T181 352T163 330L157 322L136 236Q114 150 114 114Q114 66 138 42Q154 26 178 26Q211 26 245 58Q270 81 285 1 14T318 219Q336 291 336 325Z">< /path>) hash commitment (where b refers to the byte size of the block).


Sharding is Rollup


< p line="init">ETH 2.0's sharding design obscures the fact that they are the ORU of the beacon chain. It becomes clear when the focus shifts from distributed processing to an ordered data availability layer.




As shown in the figure above, the verifier set plays the following four roles:


Validate and execute the beacon chain

for the shard provided

Form a shard committee

Submit fraud proofs for invalid state transitions


We have made two assumptions: i) data is available, ii) the blockchain will be divided from the most recent block with data availability cross. Then either people can construct fraud proofs, or the system blames the lack of data availability on the shard committee that signed the block, and rolls back the state transition.


By definition, ETH 2.0 is an ORU 


At this point, considering our previous definition of ORU, we should be able to prove that a shard is actually a rollup:


1. All transaction data is submitted to the chain


The fragmented block data is concentrated on the data availability layer, and will be verified by the entire network at a certain probability.


2. The state root is submitted to the chain


The shard committee is included in the letter The shard state root in the blockchain block provides proof.


3. The state root is assumed to be valid


Beacon chain without additional In the case of verification, it is assumed that the proof of the shard committee is valid 


4. Some nodes are responsible for verifying the state transition of the ORU


The shard committee verifies the state transition of the shard.


5. Have an on-chain fraud proof executor that can undo invalid state transitions


The beacon chain supports shard state transition fraud proofs.


Deconstructing ETH 2.0


Now that we have explained the uncanny similarity between the ETH 2.0 and ORU systems, how can we use this information to better understand the design of the overall system? Let’s explore some of the design decisions of ETH 2.0 through the lens of the ORU system.


Data Throughput


In the current design, the data of the system Throughput is tightly coupled with the sharding mechanism.


One approach that could be taken here is to treat data availability checks as first-class citizens in the protocol. This allows for independent optimization of the data layer, and finer-grained control of the hardware requirements (participating in the protocol) at the execution layer.


For example, ETH 2.0 can provide 64 data centers and an ORU contract on the beacon chain instead of the shard chain. The ORU contract allows rollups to decide on the leader election mechanism, how many data centers they want to send data to, and whether they want to be bound to other rollups (for example, if a rollup rolls back, the rollup bound to it also rollback will occur). The more datacenters used, the higher the hardware requirements required to validate rollups.


Strictly speaking, the above system is a superset of the current sharding design. In addition to the 64 shards defined by the protocol, there will be other rollups with their own characteristics built on the secure data layer and independent of the protocol shards.


Rollback Minimization


In a simple ORU, the elected leader has Submitting an invalid state transition. While this doesn't affect the security of the system, since invalid state transitions are reversible via fraud proofs, it does break the rollup process. Taken alone, this kind of damage is usually not cost-effective to the perpetrator. However, in ETH 2.0, cross-shard communication makes this problem particularly tricky. A shard in slot N expects itself to get the state of other shards in slot N-1. Assuming that shard Si commits an invalid state transition, there is no reasonable way to undo the negative impact of this state on shard Sj (0≤j≤64; i≠j) other than unilaterally initiating a rollback.


To avoid catastrophic events, there must be mechanisms in place to prevent such rollbacks. Two of the most obvious mechanisms are shard committees and custody bit checks. As stated in the section "Mathematically proving the security of shards", even considering the various attack vectors, the probability of bribing more than 2/3 of the members of the shard committee is very low. Custodial bits ensure that honest validators cannot be tricked into signing invalid state transitions due to laziness.


If we think that the purpose of these mechanisms is to prevent invalid state transitions, rather than to maintain system security, we can choose both practical value and achieve the same effect parameter. For example, reducing the size of the shard committee to 64 people, the probability of randomly forming a malicious committee is still as low as 3.1×10-8. But from a network and signature aggregation point of view, this can greatly reduce the burden.


Ethereum roadmap centered on rollup


This article was originally written during the Stanford Blockchain Conference 2020 (SBC20). At that point, I started to fully appreciate the similarities between ETH 2.0 and ORU. After reading Vitalik's article, I decided to publish this article to express my support for Ethereum's future adoption of a rollup-centric scaling solution. However, as described in this article, the "rollup-centric" scaling solution does not divert us from the direction, but a superset. The problems we encountered in sharding design were isomorphic to the problems we encountered in integrating cross-rollup communication. This means that much of the work already underway can continue without interruption.


A rollup-centric roadmap would reduce the protocol complexity necessary for sharding to execute. This allows us to continuously iterate complex rollup mechanisms like sharding. This allows more developers to contribute to different rollup formats, allowing existing core developers and researchers to focus on building a robust data availability layer.


Arguably, the path to a fully functional ETH 2.0 has never been clearer.


Original link


Welcome to join the official BlockBeats community:

Telegram Subscription Group: https://t.me/theblockbeats

Telegram Discussion Group: https://t.me/BlockBeats_App

Official Twitter Account: https://twitter.com/BlockBeatsAsia

举报 Correction/Report
Choose Library
Add Library
Cancel
Finish
Add Library
Visible to myself only
Public
Save
Correction/Report
Submit