TL;DR

Rollup centric roadmap caused fragmented and separated blockchains. This fragmentation caused lack of value transfer between rollups. As a solution to this problem, shared sequencer mechanisms emerged such as Espresso, Astria and Radius. But this solution inherently requires new trust assumptions. Because such a layer has to have its own security set.

If we want to build a shared sequencing layer for rollups, Ethereum is the most credible neutral layer that we can build/use as shared sequencer. Based sequencing (aka. based rollups) have full composability with Ethereum by nature, and the other based rollups. However, being a based rollup comes with some challenges. The most important of these challenges is that the block time is limited to 12 second same as Ethereum. The solution is a mechanism to give users fast confirmation, such as centralized sequencers, or to speed up the Ethereum block time. In testnet, based preconfirmations give preconfirmations faster than centralised sequencers today.

Crossroads

It’s good to remember Ethereum’s chosen direction at the beginning of the post. Ethereum has embraced decentralization from day one. This is the very first priority. This priority gives us some constraints on the user experience. These constraints arise from the challenges of designing a decentralized distributed system(such as dealing with global state, sequential execution, and so on). This is the exact difference between Ethereum and other L1s. They chose different paths. Other L1s chose to be fast and cheap by sacrificing some decentralization. They are fast and cheap because they have proof of history, larger block sizes, parallel processing. These concepts allow fast and cheap transactions, but they also increase the load on validators. That’s why the hardware requirements of other L1 validators are higher than Ethereum’s.

Until Ethereum itself scales with upgrades like history expiration, statelessness, verkle tree etc., we gave the mission to the rollups.

Ethereum embraced a rollup-centric roadmap to outsource execution 4 years ago to make it a more user-friendly place until the improvements arrive. Thanks to that, we’ve reached 250 TPS daily on average in all Ethereum.

rollup.wtf

As mentioned above, it’s been 4 years since Ethereum decided on a rollup-centric roadmap. During this time, there has been a lot of experimentation on L2s about “what Ethereum itself should be”. AltVMs(Fuel, Fluent), zkVMs(Aztec, Starknet), zkEVMs(Scroll, Linea, zkSync), parallel EVMs(MegaETH), and so on. All of these give an idea of the future of Ethereum itself. But it has also created many separate blockchains that don’t even have any connection between them. That’s why shared sequencing layers arrived to solve the fragmentation.

Shared Sequencing Layers

Currently, rollups have centralised sequencers. This introduces huge risks of censorship, liveness and MEV extraction. Rollups could instead opt for shared sequencers if they want to be decentralised. By using shared sequencers, rollups can take advantage of finality, decentralisation, fast transactions and cross-chain atomicity. As Vitalik says, “Decentralising the rollups involves 90% of the effort of developing a new L1”. So the engineering effort for decentralization can be avoided by opt-in to a shared sequencer.

The shared sequencing layer is basically a layer that connects the sequencing rights of the participating rollups into a single sequencer network. This layer runs a consensus protocol, such as BFT, in which anyone can participate (within the limits of the design of the consensus protocol). Thus, multiple rollups have a common mechanism for determining transaction orders. This mechanism also provide fast L2 finality and composability between all participant rollups.

The shared sequencer layer is a sequencer marketplace. In this marketplace, rollups can sell their blockspace (and proposal rights) to higher bidders slot by slot. This also creates a layer that redistributes MEV among all participating rollups.

Concerns

Shared sequencing layers have a network effect that creates atomic composability and shared MEV between all participating rollups. Rollups join the network to increase the value of their blocks (and also to decentralise their sequencer).

However, according to the system design of shared sequencers, there should be as many rollups as possible. If participant rollup X leaves the chain, this MEV distribution is disrupted and directly affects the network effect. Shared sequencing is therefore an endless game where participants must be kept in the game at all times. It’s a pure b2b model as Rushi said.

Shared sequencing layers run a protocol such as BFT for fast L2 finality next to the shared sequencer marketplace, and it’s introducing an honesty assumption. It assumes that half of the validators are honest. If for some reason half of the validators are offline or dishonest, the chain may lose liveness (they can use based fallback). If the BFT protocol loses liveness, the participating rollups can’t take advantage of fast finality because they have to certify for finality from the BFT protocol. Withdrawals from the layer will also be halted. But even if the BFT protocol is broken, the MEV redistribution will still continue, because in Espresso, for example, the MEV redistribution is separate from the BFT protocol. When compared, Ethereum will always be the strongest BFT protocol when it comes to cryptoeconomic security and liveness.

Also, they have restaking risks if they’re using it. If the hardware requirements for the validator are high, this will lead to monopoly. There may also be a mass slashing if there is an error in the restaking service; see Eigenlayer’s Risk FAQ for more. For restaking approaches in shared sequencers, see the joint research by Nethermind and Fourpillar here.

It is important to note that, given the use of preconfirmation by shared sequencers, this process can be completed on L1 (aka based preconfirmation), eliminating the need for a new layer. It should also be noted that the shared sequencer still has to go through the L1 pipeline in anyway. So “fast finality” makes no sense here.

In summary, we think that the shared sequencer layers are a single point of failure if they are not decentralised and robust. They will become the weakest link for all opt-in rollups.

Neutral composability it’s not a meme anymore: be based

As we said, Ethereum is the most credible neutral layer to build something on. Rollups do this by sending their batches/proofs to use Ethereum as the DA layer. Currently, most rollups are run by central sequencers, and all transactions are sequenced by rollup teams. Some of the teams are still working on some designs to make their network decentralised, like Aztec’s Fernet. There is also another way to make the network decentralised without spending tons of engineering resources: based sequencing.

Taiko is the very first based rollup that use Ethereum as a sequencing layer. Block building is entirely belongs to Ethereum. Anyone can propose a block, it’s completely permissionless. Every rollup can reach composability by being based. Not by adding a new layer. Since the Ethereum and based rollup slots move in tandem, they are fully compatible with each other. This means it’s possible to take a flash loan on L1 and do some activity on a based rollup in the same slot (thanks to our BBR design, read more here). But being based comes with some costs.

source: L2Beat

We touched on this issue in the “Rollup-Centric Considerations of Based Preconfimations“ article, but let’s briefly summarise. As we said, based rollups have the same 12 second block time as Ethereum. This means that based rollups need to send their data to L1 with blobs (or calldata) every 12 seconds. If you cannot fill the blob with enough L2 transactions to cover the L1 fee, you will lose money. In order not to pass this on to our users in the beginning, we covered it ourselves and spent a lot of money. Today, the block time is longer than 12 seconds (∼20s) for the proposer to be profitable.

https://dune.com/taiko_xyz/taikobcr

These are examples of the difficulties that a based rollup can experience through the example of Taiko. In summary, the main problem is the block time and the restriction of revenue to base fees only, unlike the central sequencer. You sacrifice revenue because sequencing is completely permissionless and your MEV flows entirely to Ethereum, you can’t capture any value from transactions (Spire Labs is developing a based framework to improve based rollup’ revenue model).

To solve the user experience, block times, we have two options:

1. Based preconfirmations
2. Faster block times on L1

Based Preconfirmations

Based preconfirmations simply use some of the L1 validators to give preconfirmations to L2 users. Based preconfirmations are currently working successfully on the Helder testnet, and now it’s possible to do lightning fast (20ms in Gattaca’s demo, ∼260ms in Arbitrum) transactions on Taiko.

Titan’s based preconfirmation demo

In based preconfirmations, you do not inherit all of Ethereum’s liveness and security. You only trust a subset of Ethereum’s validator set. But it’s good to mention here that we’re getting a credible commitment from the current Ethereum proposer. Anyone can be a preconfer (preconfirmation provider) by staking an exact amount of ETH on the registry contract. We explained the details of based preconfirmation in our previous blog post, see here.

Based preconfirmation space is still in its early and evolving stages. It has some threats, just like the centralization of Ethereum block building, but with new approaches and research, a much more reasonable architecture will be designed. We will share our preconfirmation design soon.

Faster Blocks?

Nobody would say no to making Ethereum more user friendly. Faster finality, faster block times and faster transactions. This is the most useful scenario for a based rollup because, as we said, L1 block times is the only obstacle to being based. Faster L1 block means faster based rollup blocks.

The main idea for a faster L1 is a consensus that natively reduces slot time. Single Slot Finality(SSF) is a consensus mechanism(Orbit SSF in more spesific) being considered, where each slot can be finalised in a few seconds. In the current Gasper protocol, the finalisation time is 2 epochs, i.e. 13 minutes. However, the disadvantage of SSF is that it is vulnerable to 33% inactivity leakage.

The main question here is why, if a faster L1 is always a necessity, the engineering effort spent on four years of rollups is not used to speed up the L1 itself. We put a lot of R&D effort into rollups. We have done a great job and achieved many different approaches. Even if shorter block times were agreed today, it will take 2-3 years at best to develop.

Ethereum has chosen a very clear path. This path means no compromises on decentralisation and no touching of “solo home stakers”. It is obvious that fast blocks require a change in Ethereum’s consensus, and that this changed consensus will lead to a much lower validator distribution than now. This is an important decision for the Ethereum community to make.

Conclusion

As rollups develop and become more popular, fragmentation and isolation become serious problems. Therefore, being a based rollup and joining shared sequencer layers is an important distinction. Shared sequencing layers can be used for fast finality and cross-chain composability, but they require new trust assumptions and they could fail and loses the network effect. Based rollups use Ethereum’s existing infrastructure for block building, but face challenges with block times and revenue models. But it does offer a solution to the liquidity fragmentation by nature and fully composability with the L1.

The way forward may lie in new solutions like based preconfirmations and faster L1 block times to overcome the disadvantages of based rollups. These aim to improve the user experience without compromising Ethereum’s alignment. The goal is to create a scalable, decentralized and user-friendly ecosystem that stays true to Ethereum’s vision.

The choice to be based or not is more than a technical decision. It is about the direction of decentralized rollup “framework”.

Join us

Explore open positions on our job board.

Follow us

Get the latest from Taiko:

1. Website: https://taiko.xyz.
2. Discord: https://discord.gg/taikoxyz.
3. GitHub: https://github.com/taikoxyz.
4. Twitter: https://twitter.com/taikoxyz.
5. Community forum: https://community.taiko.xyz.
6. YouTube: @taikoxyz"">https://www.youtube.com/@taikoxyz.
7. Warpcast: https://warpcast.com/taikoxyz.

Contribute

Contribute to Taiko on GitHub and earn a GitPOAP! You will also be featured as a contributor on our README. Get started with the contributing manual.

Disclaimer：

1. This article is reprinted from [mirror], All copyrights belong to the original author [Taiko Labs&Jünger]. If there are objections to this reprint, please contact the Gate Learn team, and they will handle it promptly.
2. Liability Disclaimer: The views and opinions expressed in this article are solely those of the author and do not constitute any investment advice.
3. Translations of the article into other languages are done by the Gate Learn team. Unless mentioned, copying, distributing, or plagiarizing the translated articles is prohibited.