Radius: Shared Sequencing powered by EigenLayer
Article1,387 words
Long-form on why centralized sequencers hurt censorship resistance, liveness and safety, and how Radius's encrypted mempool (PVDE then SKDE) and EigenLayer AVS deliver MEV-resistant shared sequencing and cross-rollup composability.
Key claims
Radius moved from PVDE to SKDE encrypted mempool in April
Loggia, its third testnet, is built on an EigenLayer AVS
Shared sequencing demonstrated on Madara-based rollups
Radius: Shared Sequencing powered by Eigenlayer
Decentralizing the sequencer is the next frontier of L2 innovation, permissionless composability is the holy grail of the modular thesis and malicious MEV remains a billion dollar problem.
Shared sequencing can solve all of this at once. 馃く
Let me introduce you to this emerging billion $$$ narrative and @radius_xyz, one of the most innovative players in the game that is first to add restaked security powered by @eigenlayer to the mix.
Are you ready for alpha anon?
Monolithic ecosystems like Ethereum or @Solana have grown into multi-billion $$$ on-chain economies because of the wave of permissionless innovation that allows anyone to build with pre-existing primitives and combine them into new, disruptive protocols.
DEXes, lending markets and yield farming protocols need each other to unleash the full potential of the programmable financial infrastructure that is DeFi.
In an increasingly fragmented modular multichain future, that is currently materializing around us, achieving composability is more difficult unfortunately.
馃 Why?
Applications are scattered across execution layers that have their own logic and rules of what constitutes a valid transaction.
Let's think about L2s. 馃憞
@arbitrum, @Optimism, @zksync or @starknet all settle on Ethereum, which means that the final state validation happens there. However, the mechanisms they use are vastly different. They also all post data to Ethereum, or rather EIP4844 data blobs, but do so asynchronously.
Hence, while all L2s can communicate with the L1 through the native bridge, this path is often too expensive and slow if a user wants to move funds across L2s and definitely not feasible for cross-chain interactions where speed & cost are a priority.
Communicating across the borders of these inherently isolated ecosystems is a complex endeavour, especially if we aim to do so without introducing major, additional trust assumptions.
If we don't overcome this friction, the modular thesis will not reach its full potential. What is missing, is a layer that sits above execution and that acts as a coordination layer for a truly decentralized rollup economy.
馃 Above execution?
Don't worry, this sounds more complex than it is.
I'm not talking about anything new here.
I'm talking about the sequencer, or if we don't want to assume a centralized setup, the sequencing layer.
The sequencing layer is responsible for batching and ordering transactions in rollup blocks that are subsequently proposed for for execution. The sequencer also provides a pre-confirmation (a.k.a. promise L1 block inclusion), that enables the fast UX users are used to on L2.
However, all major rollups currently still rely on centralized sequencers that are being operated by the team and that are dedicated to sequencing only one specific rollup.
Centralized architectures come with several critical concerns:
Censorship risks: Centralized sequencers have the power to potentially censor user transactions.
Liveness issues: Rollups suffer from weak liveness when relying on a single, centralized sequencer. This creates a single point of failure that could halt the entire rollup operations.
Safety concerns: As more participants are involved in the finalization process, the integrity and the security of sequencer commitment become more vulnerable.
But back to the interoperability part! 馃憞
Because of the isolated sequencing, there is also no coordination happening for transactions that a user potentially wants to make across execution layers.
If a sequencer is shared across rollups, a user can send transactions on rollup A to the sequencer to have it executed on rollup B.
This works because there is a single entity that proposes blocks to the rollup nodes of all the chains plugged into the shared sequencer. Hence, these chains don鈥檛 necessarily need to rely on other validators to include these atomic transactions.
Important to note, that this is a slightly simplified explanation and there are some limitations here. Since the sequencer doesn't execute transactions (only promise that they will be included in a L1 block), there is contingency on other rollups actually executing the atomic transactions that the shared sequencer proposes. This might make some use cases (e.g. mint & burn bridging) harder to realize.
But there are workarounds here too and the possibilities are huge.
Okay so let's summarize:
All rollups have a sequencers
Most are currently centralized
This is not ideal due to multiple risk factors
All are currently isolated (only sequence one L2)
Leaves coordination potential at sequencing layer untapped
Now, to understand how a solution could look like, let's think about what in an ideal world, users expect from the sequencing layer.
With that, let's dive into @radius_xyz. A shared sequencing layer that provides rollups with...
Fast, crypto-economically secured pre-confirmations
Enhanced censorship resistance
Improved liveness
MEV resistance (thanks to encrypted mempool)
...and will solve both the problem of centralized sequencers, as well as isolated ecosystems with its AVS-based cross-rollup coordination layer, secured by @eigenlayer.
馃 What makes Radius special?
In November 2023, @radius_xyz launched the Curie Testnet, which introduced ground-breaking developments for encrypted mempool and ZK-powered Practical Verifiable Delay Encryption (PVDE).
PVDE is a zero knowledge (ZK) cryptography scheme and instrumental in ensuring trustless sequencing of transactions. It's crucial in keeping centralized sequencers from engaging in malicious actions such as frontrunning, sandwiching or censoring user transactions.
This kind of MEV resistance is achieved as the contents of the transaction are only revealed after the transaction order is determined by the sequencer.
@Radius_xyz encrypts the transactions temporarily based on a time-lock puzzle, which adds a time delay for the operator to find the symmetric key used to decrypt the transaction data.
These innovations provide base solutions for decentralized and trustless sequencing while maintaining the fast and seamless user experience of a centralized sequencer.
Since then, @radius_xyz has continued to innovate at the forefront of enhancing rollup composability, security and MEV prevention.
Back in April, they introduced a new encrypted mempool model, based on Single Key Delay Encryption (SKDE), which improves on the earlier PVDE model and that inherits the advantages of Multiparty Delay Encryption while addressing its two main drawbacks, namely the unfavourable trust assumption and high gas fees.
In the subsequent Portico Testnet, @radius_xyz demonstrated their first shared sequencing on Madara-based rollups. @MadaraStarknet is an open-source stack on @Starknet empowering developers to build app-chains using Cairo and Starknet technology.
The integration sequences prevents censorship and reordering, adding a layer of security and reliability, and opens the door for cross-rollup composability.
Last week, @radius_xyz launched its third testnet iteration "Loggia". It is built on the three core pillars of decentralized sequencing:
Censorship Resistance: Cryptographic sequencing module to ensure censorship resistant pre-confirmations for users.
Sequencing Liveness: Guarantees continuous block creation using leader selection algorithms. This determines the next block proposer and facilitates data broadcasting between sequencers*.
Block Safety: Implements an order validation process to verify that blocks are created in the promised order.
* ) ensuring all nodes maintain the same data and network-wide liveness.
馃 How does Radius achieve this?
A central component of Loggia is the @radius_xyz AVS (Actively Validated Service), built on @eigenlayer.
It is specifically designed to provide sequencing liveness and block safety guarantees for decentralized sequencing.
@eigenlayer operators on the Radius AVS contribute to the economic security of decentralized rollups through two main functions:
Ensuring sequencing liveness by synchronizing transaction lists
Guarantees block safety by verifying block order
@radius_xyz's block validation mechanism ensures fair and proper rewards for all operators, implementing a rotation of leader roles among follower sequencers for each new block.
This approach promotes active participation and maintains a balanced, decentralized system and decouples sequencing and execution, allowing the Radius AVS to optimize rollup performance with high-performance decentralized sequencing.
As a result, rollups achieve greater efficiency, improved security, and enhanced decentralization.
By leveraging Ethereum's crypto-economic security, it also boosts censorship resistance, sequencing liveness, and block safety.
Additionally, the sequencing layer secured by restaked $ETH through @eigenlayer will serve as a powerful coordination layer in the future and allow for the cross-rollup composability outlined earlier*.
* ) Initially, the decentralized sequencer sets will be bootstrapped individually for rollups based on the Radius operator set.
Recently, @radius_xyz announced a first rollup integration with @VesselFinance, a ZK-powered orderbook exchange that is soon to become the first L3 on @Scroll_ZKP.
Just one of many projects that Radius is working with on the path towards a future of truly decentralized and secure rollups that are seamlessly composable with each other across stacks, layers and VMs.
馃 DYOR anon!
What came next 路 since 03 Jul 2024
Since then
Zero has written 1 more piece on Radius since this one.