The Great Sequencing Debate�

Debate 1: To share or not to share?�Justin Drake (EF) vs Dankrad Feist (EF)

Moderator: Ellie Davidson (Espresso Systems)

​

Debate 2: Based or non-based?�Justin Drake (EF) vs Josh Bowen (Astria)

Debate 1: shared vs non-shared sequencing

Non-shared sequencing: each rollup has its own isolated protocol that determines sequencer of rollup transactions.

3

Layer 1 nodes verify (fraud/zk proofs)

rollup

rollup

rollup

rollup

rollup

• Smart-contract endows protocol with ability to finalize L2 blocks conditioned on some L1 state
• Smart-contract may be able to force include transactions ignored by protocol for too long

​

Shared sequencing: rollups share this protocol

4

Layer 1 nodes verify (fraud/zk proofs)

rollup

rollup

rollup

rollup

rollup

Users send txs to L1

• Simplest case: rollups share a centralized party for sequencing
• Much wider design spectrum for shared sequencing protocol
• Bisected into two shared components:

1. Proposer assignment: determining set of proposers for next rollup blocks
2. Finality Gadget: finalizing proposed blocks, providing confirmation to users

Shared sequencing: rollups share this protocol

• Simplest case: rollups share a centralized party for sequencing
• Much wider design spectrum for shared sequencing protocol

Layer 1 nodes verify (fraud/zk proofs)

Fast Finality Gadget (w/ L1 validator opt-in participation)

Assigned proposer

superblock

L1 is the default shared finality gadget if none other!

Examples of shared proposer assignment

• Fixed shared-proposer set: The group of rollups share a fixed set of proposers and a protocol to rotate among them (e.g., randomly, round-robin, etc)

​

• “OG” based sequencing: Same as above, with L1 validators forming this set and rotation determined by L1 beacon (the L1 proposer is always the proposer for all rollups as well)

​

• Dynamic auction (aka marketplace): Group of rollups participate in a shared (combinatorial) auction.

• Rights to propose (bundles of) rollup blocks sold to highest bidders
• Each rollup sets a reserve price + assigns default “sequencer” to propose if the price isn’t cleared
• L1 proposer may participate in the auction, possibly with some privilege (e.g., ROFR)

The question: Is it a desirable future to have global shared sequencing (where Eth L1 and virtually all rollup blocks are sequenced by the same entity within one slot)?

��Note: there might be independent value in sharing a finality gadget (separate from L1) but this is out of scope

Common arguments for shared proposer assignment..

• Optimizes for cross-domain user intent satisfaction (proposer can make promises to users on what it will proposer, e.g. for cross-chain arbitrage, or atomic exchange, etc) �
• Combined with real-time zk proofs enables synchronous composability between applications on different rollups (and the L1 with based sequencing)

​

​

​

• Specialized parties (due to natural incentive) will try to become shared proposers across rollups even if they have independent proposer assignment mechanisms! Thus best to get ahead of this w/ design that achieves better decentralization (reduced risk, lower barriers to entry, etc) �

• Even without real-time proving can coordinate message passing between zk rollups with proofs that are later aggregated and settled (like Polygon Agglayer)

Common arguments against shared proposer assignment..

• Not optimized for frontrunning prevention. If shared proposer isn’t trusted (unlikely to find single trusted sequencer for all rollups) or elected randomly or by auction, it will maximize rent-seeking behavior. �
• Create bottlenecks that reduce performance of the L2�
• Some rollups simply don’t benefit from it, better to let them optimize performance�
• Rollups want to keep their MEV instead of giving it up to shared proposer (though this is also addressed by dynamic auctions / marketplace)�

Debate 2: based vs non-based sequencing

“Based” sequencing (original version)

11

Layer 1

rollup

rollup

rollup

rollup

rollup

Users send txs to L1

L2 nodes read the finalized tx list from L1 and execute to determine state transition

Advantages

• Inherits decentralization, liveness, and censorship resistance of the L1
• Improved interoperability not only between rollups but also between rollups and L1 applications

Or separate shared sequencing layer 1.5

12

Layer 1 nodes verify (fraud/zk proofs)

Layer 2 nodes execute and prove state transitions

rollup

Layer 1.5 (tx ordering and availability)

rollup

rollup

rollup

rollup

“Based” sequencing 1.0 (w/ preconfers)

13

Layer 1 (preconfers only)

rollup

rollup

rollup

rollup

rollup

Users send txs to L1

L2 nodes read the finalized tx list from L1 and execute to determine state transition

• Only L1 proposers that restake as “L1 preconfers” are given sequencing rights
• Next L1 preconfer in the set can start proposing L2 transactions once prior L1 preconfer hs finished proposing its own L1 block

Based sequencing 2.0 (external finality gadget)

Layer 1 nodes verify (fraud/zk proofs)

Fast Finality Gadget (w/ L1 validator opt-in participation)

L1 proposer

superblock

Can also require L1 proposer to purchase this right!

The fast finality vs composability tradeoff of being a “based” rollup

Based rollups w/ shared finality-gadget

​

• Transactions on rollup have dependence on unfinalized Ethereum L1 state
• Synchronous interactions with L1
• Fast-Finality Gadget provide conditional finality

Non-based rollups w/ shared finality-gadget

​

• Transactions on rollup only depend on finalized Ethereum L1 state
• Only asynchronous interactions with L1
• Fast-Finality Gadget provides unconditional finality

Common arguments for based sequencing..

• Enables L1 proposer to make promise (aka preconfirmations) for user intents across the L1 and L2 states (e.g., atomic execution)

​

• Combined with real-time zk proofs enables synchronous composability between L1 applications and applications on rollups�
• Inherits liveness of the L1 (especially in the OG based rollup design with no external finality gadget or opt-in preconfers) �
• Better L1 economic alignment (at least some value flows to L1 proposers)

​

• Finality tradeoff is overrated… reorgs are rare, safe block usually occur quickly, and single slot finality will improve the situation even further

Common arguments against based sequencing..

• Finality tradeoff: to benefit from synchronous composability with L1 the rollup state is now dependent on L1 reorgs (even single block), can’t give preconfirmations without risk �
• When proposer is selected via auction or L1 beacon rather than based on trust we should expect maximum rent-seeking (MEV) behavior like frontrunning �
• Threshold encryption (for frontrunning prevention) reduces benefits of based sequencing anyways because harder to produce preconfirmation for unknown state, or achieve synchronous composability �
• Doesn’t benefit from data compression (mostly pertains to original design, alternative designs where L1 proposer participates in external finality gadget allows for same data compression as other non-based rollup)

Questions

• What percentage of L1 validators need to be opted in to based sequencing for it to be considered “based?”