Rollup Sorter Decentralization: Analysis of Technology Trends and Cutting-edge Solutions

Preface

The sequencer is one of the core components in the Ethereum scaling solution Rollup. It is responsible for sorting transactions and performing related tasks such as block creation, transaction acceptance, transaction sorting, transaction execution, and transaction data submission. With the continuous increase of Layer 2 solutions in the Ethereum network and the booming development of its ecosystem, the profit model and centralization of Layer 2 have received increasing attention. Especially in Rollup, how to achieve the decentralization of the sequencer and the distribution mechanism of the sequencers profits have become hot topics of concern.

What is a sequencer?

As the name implies, the sorter is responsible for sorting transactions. In the Bitcoin network, the responsibility for transaction sorting is the responsibility of miners; in the Ethereum network, this responsibility is undertaken by a collection of nodes. These roles are not fixed, but a consensus mechanism is used to determine who has the right to participate in the order of transaction execution.

Currently, most mainstream Rollup solutions run a centralized single sorter. The users transactions in Layer 2 (L2) first enter the mem pool (at this time, the transactions are out of order). The sorter sorts these transactions, compresses them into a set of ordered batches, and then sends them to Ethereums data availability (DA) layer.

Centralization vs Decentralization

Overview of the decentralized sequencer track

Decentralized sequencers can be implemented in two ways: one is developed by the Rollup project itself, and the other is to use third-party services. Using a third party to implement a decentralized sequencer is usually called Sequencing-as-a-Service.

Currently, there are multiple projects focusing on decentralized sequencer solutions, including Espresso, Astria, SUAVE, Radius, etc. Although their implementation paths are different, the goal is to improve the decentralization and reliability of the sequencer.

Espresso

Under the sorting mechanism of the Espresso sorter, L2 transactions roughly go through the following life cycle:

• Transaction sending: The transactions made by users on the second-layer network are sent to the Rollup server through the API.

• Transaction sorting: After the transaction enters the mem pool, the sorter sorts the transaction through HotShot consensus election and includes it in a block.

• Transaction broadcast and confirmation: The sorter broadcasts the sorted transactions, and other nodes reach consensus through HotShot consensus and then generate blocks, and the transactions are executed. At the same time, the soft commitment mechanism provides fast transaction confirmation.

• Block Commitment: The sorter sends and stores the block commitment containing the transaction and its consensus certificate (QC: Quorum Certificate) in the L1 sorter contract, proving that the block has achieved soft finality through consensus.

• Status update: The Rollup node that has executed the block sends the new Rollup status to L1. In the case of zkRU (zero-knowledge Rollup), a validity proof is required, while in the case of ORU (optimized Rollup), a challenge period will be entered.

• State Verification: The L1 Rollup contract checks the validity of the state update by verifying the QC sent by the sorter contract.

This process can be simplified as follows:

• Transaction sorting and block creation: Among a group of sorters, a sorter is selected through the HotShot consensus mechanism, which is responsible for sorting Rollup transactions and including them in a block.

• Consensus and block commitment: The block must be signed and agreed upon by other Rollup nodes (at least 2/3 of the HotShot nodes agree) to be final. Then, the relevant block commitment and the new Rollup state root are submitted to the L1 base layer for verification.

• Fast confirmation and finality: The quotation marks around “finality” are to make Rollup transactions faster to confirm, reduce latency, and improve user experience. However, Rollup transactions must ultimately be verified by the L1 base layer (zkRU needs to verify the validity proof, and ORU needs to wait for the challenge period to end). If there is no problem with L1 verifying the transaction, the Rollup transaction will then have true finality.

• Potential rollback: If L1 verification finds that the transaction is invalid, the related L2 block that has been produced will face rollback. Therefore, finality is to make transactions confirmed quickly, and finality is to inherit the security of Ethereum.

Astria

Astria is positioned to provide a general, permissionless, decentralized sorter that provides out-of-the-box shared sorter services for different Rollups.

Operation Mechanism

Astria’s decentralized sequencer operates in a similar way to Espresso Sequencer, with the goal of reducing sequencer privileges by delegating the power of transaction ordering. Specifically, Astria proposes two rotation mechanisms for sequencers:

• Leader Rotation: This is a simple rotation mechanism that rotates leaders between sorters through predetermined rules or time intervals, thereby distributing sorting power.

• Byzantine Fault Tolerant (BFT) consensus algorithm: This is a more complex and secure mechanism that allows consensus to be reached even in the presence of malicious nodes. Through this algorithm, multiple sorters jointly participate in decision-making to ensure that the system can still operate normally when a certain number of node failures or attacks occur.

Leader rotation

The elected sorters form a set, and the sorters in the set take turns to sort the Rollup transactions. This method avoids the problem of a single sorter monopolizing the transaction sorting rights for a long time, and to a certain extent solves the concern about continuous censorship of users.

SUAVE

SUAVE is a decentralized, plug-and-play shared sorter solution developed by Flashbots. As a general platform, SUAVE can provide memory pool management and decentralized block building functions for various L1/L2 networks. Unlike traditional shared sorter designs, SUAVE Chain is an EVM-compatible chain that implements transaction sorting through a block bidding mechanism.

SUAVE Architecture

SUAVE’s architecture consists of three core components: a universal preference environment, a best execution market, and decentralized blockchain construction.

• Preferred environment

• SUAVEs preference environment covers a wide range of needs from simple transactions to complex events. The users transaction preferences are reflected in the memory pool in the form of transactions, and the preference environment aggregates these preferences as a public memory pool. The universal preference environment provided by SUAVE not only makes the preferences of multi-chain users public and transparent, but also effectively reduces information asymmetry and alleviates the cross-chain MEV problem to a certain extent.

• Execution Market

• The execution market consists of a group of executors who are responsible for listening to SUAVEs memory pool and competing with each other. Competition drives these executors to provide the best execution solutions for users preferences. These executors can be regarded as participants who fulfill user needs through bidding, and they strive to return as much MEV as possible to users.

• Decentralized Blockchain Construction

• Finally, based on the collected preference data and the best execution path, the decentralized block construction network will package these transaction information into blocks, completing the entire process from transaction discovery, sorting to block generation.

Radius

Radius is positioned as a trustless shared sorting layer. Different from the implementation mechanism of the previous scheme, Radius introduces an encrypted mempool to ensure that the sorting process of Rollup transactions is trustless. This method effectively eliminates the problem of MEV and user transaction review, thereby ensuring the fairness and transparency of transactions.

Although consensus-based decentralized sequencers such as Espresso and Astria reduce MEV and censorship risks to a certain extent, they usually sacrifice network scalability and time efficiency, resulting in delayed transaction confirmation (because consensus needs to be reached on transaction ordering). In addition, although these sequencers operate in a decentralized environment, since transaction information in the memory pool is public and transparent, there is still a risk of malicious MEV grabbing by the sequencer. Radius introduces an encrypted mempool to ensure that the sequencer cannot see the relevant transaction information, aiming to fundamentally solve the problem of malicious MEV grabbing and censoring transactions by the sequencer.

Technology Architecture

Radius technical architecture is divided into four main functional layers: sorting layer (Radius), execution layer (Rollup), settlement layer, and data availability layer.

• Sorting Layer

• The user submits the encrypted transaction and its proof to the sorter.

• The sorter verifies the validity of these proofs and transactions.

• The sequencer sorts the transactions before decrypting them.

• The sorter builds a block.

• The sequencer submits the constructed blocks to the Rollup execution layer.

• Execution Layer

• Rollup receives blocks submitted by the sequencer and executes transactions in the specified order.

• Rollup submits the transaction status and status proof to the settlement layer.

• Settlement Layer

• The settlement layer is responsible for receiving and verifying the state and state proofs from the Rollup to confirm the finality of the transaction.

• The settlement layer ensures that transactions are executed in the order specified by the sorting layer.

• Data availability layer

• The data availability layer is responsible for storing data and ensuring the availability of that data.

Mempool encryption mechanism - PVDE

Radius uses a zero-knowledge proof-based encryption scheme called Practical Verifiable Delayed Encryption (PVDE) to implement an encrypted memory pool (mempool). This mechanism ensures that transactions remain encrypted during the sorting process, increasing the security of transaction processing.

The specific process is as follows:

• User submits transaction

• The user generates a time-lock puzzle and a symmetric key.

• Users use symmetric keys to encrypt transactions, and the encrypted transactions enter the mempool.

• The sequencer processes transactions

• The sequencer sorts the encrypted transactions but cannot obtain the decryption key until the time-lock puzzle is unlocked.

• Before unlocking the time lock puzzle, the sequencer calculates the order commitment and submits it to the settlement layer. This commitment is used to verify whether the sequencer submits transactions to the Rollup execution layer in order.

Metis

Metis is one of the first Layer 2 networks to implement a decentralized PoS sorter, providing an important template for future development. This template not only achieves the decentralization of the sorter, but also provides a decentralized Optimistic Rollup solution based on PoS (Proof of Stake). In this template, Metiss decentralized PoS sorter includes three main roles: administrator, sorter, and PoS consensus layer.

In the traditional Rollup model, a single Sequencer can effectively process transactions and data, but it also concentrates power and may cause a variety of risks:

• Operational risk: If the Sequencer fails or is attacked, transaction processing of the entire system will be blocked.

• Censorship Risk: Sequencers are able to selectively process or reject transactions, which could limit user access to specific decentralized finance (DeFi) protocols or services.

• Manipulation Risk : Sequencers may prioritize their own transactions in transaction sorting and gain unfair benefits by increasing transaction fees, namely the Maximum Extractable Value (MEV).

To solve these problems, Metis designed a decentralized Sequencer pool, where multiple Sequencer nodes work together to aggregate, sort, and execute transactions. This design ensures the fairness and transparency of the system:

• Consensus mechanism: More than two-thirds of the Sequencer nodes must reach a consensus on the status of each new block before the transaction batch can be submitted to the Ethereum mainnet (L1).

• Multi-party computation (MPC) signature: Before the transaction batch is submitted to L1, the authenticity of the batch is verified through the MPC signature to ensure the accuracy of the data.

Advantages of decentralized sequencer:

• Enhanced security: Joint decision-making by multiple nodes reduces the risk of single point failure and improves the robustness and security of the network.

• Reduce the possibility of censorship and manipulation: The existence of multiple sequencers makes it difficult for a single node to manipulate or censor transactions, protecting users trading freedom.

• Stability and redundancy: Supports smooth rotation of sequencers, minimizes the impact of failures or interruptions, and improves the stability of the entire network.

In Metis decentralized sequencer model, each node consists of several key components:

• L2 Geth (including OP-Node): responsible for transaction sorting and block assembly.

• Adapter module: acts as an intermediary for interaction with other external modules (mainly PoS nodes).

• Batch Proposer: Responsible for building transaction batches and submitting them to L1 after obtaining approval from multiple Sequencers.

• PoS Node: Coordinates between the Ethereum, consensus, and Metis layers to ensure secure locking of assets and reward validators.

• Consensus layer: Consists of Tendermint PoS nodes running in parallel with the Ethereum mainnet, ensuring operational efficiency without hindering the progress of the mainnet.

L2 Geth (including OP-Node)

The main code is https://github.com/MetisProtocol/mvm fork optimism

Mainly modified two parts

1. Block assembly: mvm\l2 geth service code, added applyTransactionToTip processing logic to determine whether the current sequencer should assemble the current block.

2. Transaction sorting: Modify the original op-node code, use the adapter module of the MPC consensus layer to obtain the position of the current sorter corresponding to the rotation list and block height, and check whether it is the current valid sorter.

Sequencer rotation

• The rotation information is stored in the L2 MetisSequencerSet contract, and the information is controlled by the consensus layer (PoS node)

• In each epoch, the consensus layer updates the Sequencer information, signs the MPC, initiates the transaction, and updates the contract Sequencer list.

• Each epoch, according to the contract sequencer list information, take turns to serve

• Violation: If the transaction is not timely or an erroneous transaction is generated (two identical L2 TxIDs), the PoS layer will select a new Sequencer, {construct a ReselectSeqencer transaction + MPC signature}, and the new Sequencer will initiate a transaction of the current TxID on L2. At the same time, the new Sequencer will also be updated to the MetisSequencerSet contract {no penalty mechanism}

• Trigger update: When a regular transaction is received and the rotation interval is reached, the current regular transaction will be suspended, the MetisSequencerSet.sol contract update transaction will be executed, and then the PoS layer will select a new sorter that will execute the current regular transaction.

• Add: POS contract, deployed on L1, anyone can pledge metis and apply to become a sequencer. When the upper limit is reached, enter the waiting queue

• Get an NFT

• Direct transfer is prohibited. You can change the signer and transfer NFT through LockingPool contract->updateSigner

• NFTs tokenId corresponds to the sequence id

• Replacement: When a sequencer is in an unhealthy state for a long time, it will be kicked out and replaced by a candidate.

• quit:

• Destroying NFTs

• update: Change the signer through LockingPool contract->updateSigner and transfer NFT

• Selection: Weighted random selection algorithm

MPC Module

Responsible for managing the entire life cycle of multi-signature keys

1. Multi-signature generation

2. Key re-sharing

3. Application Signature

4. Delete Signature

5. Provides support for asynchronous use of multiple multi-signatures

Processing Flow

Phase 1: Notify MPC nodes to prepare

• Generate a random sessionID locally;

• keyGenPrepare uses the p2p network to broadcast messages to all MPC nodes;

• After receiving the keyGenPrepare message, each MPC node starts its own processing goroutine;

• According to checking local data (data refers to whether the TSS module stores the mpc information corresponding to the id) keyId;

• If there is data in the READY state, the data is returned directly from the storage without continuing to operate keyGen;

• If data with PENDING status already exists, an error is returned to avoid inconsistent key generation due to concurrent execution of different key generation calls;

• Establish a p2p communication channel;

• Return the keyGenReady message to the initiating node;

Phase 2: Starting the keyGen process

• The initiating node waits to receive keyGenReady messages from all nodes;

• Once the initiating node receives keyGenReady messages from all nodes, it broadcasts keyGenStart messages to all MPC nodes using the p2p network;

• After receiving the keyGenStart message, each MPC node:

• Construct a LocalParty instance locally;

• Start receiving information from other nodes

Outlook

The future of blockchain sorters is full of exciting changes. As the blockchain ecosystem continues to evolve, sorters will undergo a major transformation from centralized to more decentralized, efficient, and adaptable solutions. This transformation is critical to improving the transaction efficiency, scalability, and security of the Ethereum ecosystem.

Decentralization is the core philosophy of cryptocurrency. Through a shared sorting network, economic mechanisms can effectively solve the problems of value accumulation and income distribution. With the increasing maturity of the modular construction and development framework of the sorter, these technologies will become a powerful catalyst for the development of the industry in the future, driving the blockchain ecosystem towards a more innovative and efficient direction.

References

• https://docs.espressosys.com/sequencer

• https://docs.theradius.xyz/

• https://docs.astria.org/developer/tutorials/run-local-rollup-against-remote-sequencer

• https://docs.metis.io/dev/decentralized-sequencer/overview