Why shared sequencing matters
In a standard rollup setup, each layer-2 network operates as an isolated island. Users submit transactions to a single sequencer that orders them within that specific chain. This isolation creates a bottleneck: if you want to interact with assets across different rollups, you must wait for separate block times and finality periods. The result is high latency, fragmented liquidity, and increased exposure to Maximal Extractable Value (MEV) as bots exploit the time gaps between isolated execution environments.
Shared sequencing replaces these isolated domains with a common ordering layer. A shared sequencer is a decentralized network of nodes that receives transactions from multiple rollups simultaneously and assigns them a global order. By treating cross-rollup transactions as part of a single stream, the system can execute them atomically. This means a trade on Rollup A and a corresponding update on Rollup B happen in the same logical step, eliminating the need for asynchronous bridging.
This approach transforms cross-rollup composability from a slow, multi-step bridge process into a near-instantaneous operation. For developers implementing cross-rollup sequencing, this shift is foundational. It reduces the complexity of state management and allows applications to treat multiple rollups as a single, unified execution environment.
Set up the shared sequencer node
A shared sequencer acts as a common ordering layer for multiple rollups, replacing isolated sequencing domains with a single point of transaction ordering. Setting up this node requires configuring RPC endpoints for each connected rollup and ensuring low-latency network connectivity. The following steps outline the technical installation and configuration process.
Begin by cloning the shared sequencer repository from the official source. Use the standard build commands for your operating system. Verify the installation by running the version check command to ensure all dependencies are resolved before proceeding to configuration.
Edit the sequencer configuration file to include the JSON-RPC endpoints for every rollup that will share this sequencer. Each rollup must expose a reliable endpoint that the sequencer can query for transaction submission. Ensure the endpoints support the required WebSocket connections for real-time transaction ordering.
Launch the sequencer process using the configuration file created in the previous step. Monitor the console output for connection confirmations from each connected rollup. Use the health check endpoint to verify that the sequencer is actively receiving and ordering transactions from all specified rollups.
Configure transaction routing rules
Defining which transactions from different rollups are eligible for shared ordering requires precise configuration of routing rules. These rules act as the traffic controller, determining how the sequencer batches and orders transactions across distinct L2 environments. Without clear routing logic, you risk state inconsistencies or failed cross-rollup swaps.
Define eligibility criteria
Start by identifying the specific transaction types that require shared ordering. Typically, this includes atomic swaps, bridge deposits, or cross-chain messaging where execution on one rollup depends on the outcome of another. Configure your sequencing logic to tag these transactions with a shared namespace or priority queue.
For example, if you are implementing shared settlement for cross-rollup swaps, ensure your routing rules can detect the intent to swap without requiring external asset wrapping. This allows the sequencer to group related transactions from different rollups into a single batch, reducing latency and gas costs.
Establish data availability proofs
Routing is not just about ordering; it is about guaranteeing that the data behind these transactions is available and verifiable. Configure your routing rules to require valid data availability proofs before a transaction is included in the shared sequence.
This step is critical for maintaining consistency. If a transaction is routed for shared ordering but its data is not promptly posted to a data availability layer (like Celestia or Ethereum DA), the sequencer cannot safely commit it. Your configuration should include timeouts and fallback mechanisms to prevent the sequencer from stalling on invalid or pending data.
Implement priority and fee structures
To manage congestion and ensure fairness, define priority levels for different transaction types. High-priority transactions, such as those involved in atomic cross-rollup execution, should be processed before standard, independent transactions.
Configure fee structures that reflect this priority. Users initiating cross-rollup sequences may need to pay a slight premium to incentivize the sequencer to include their transactions in the shared batch. This ensures that the sequencer remains economically viable while providing low-latency execution for complex multi-rollup operations.
Validate routing logic
Before deploying your configuration to mainnet, validate the routing logic in a test environment. Use a testnet that mirrors your production setup, including multiple rollup instances and a shared sequencer.
Test edge cases, such as simultaneous transactions from different rollups targeting the same state. Ensure your routing rules correctly handle conflicts and that the sequencer can resolve them without violating consistency guarantees. This validation step is essential for preventing state divergence and ensuring reliable cross-rollup sequencing.
Handle atomic execution failures
When a cross-rollup sequence spans multiple networks, the probability of partial failure increases. A transaction might succeed on Rollup A but fail on Rollup B due to a state mismatch or a temporary network outage. Without a robust rollback mechanism, this divergence leads to stuck funds or inconsistent state across the ecosystem.
Implementing the Rollback Protocol
To prevent state divergence, the sequencing layer must treat the entire cross-rollup transaction as a single atomic unit. If any step in the sequence fails, the system must trigger a rollback that undoes all previously successful operations. This is typically achieved through a two-phase commit protocol or a state-revert function that restores previous block states.
- Detect Failure: The sequencer monitors the execution status of each rollup. If a transaction is rejected or times out on any rollup, the failure flag is raised immediately.
- Initiate Rollback: The sequencer broadcasts a rollback command to all participating rollups. Each rollup executes a state revert operation, returning to the block state prior to the sequence start.
- Confirm Reversion: The sequencer waits for confirmation from all rollups that the rollback was successful. Only then is the entire transaction marked as failed and discarded.
Handling Sequencer Outages
Sequencers are the single point of failure in many rollup architectures. If a sequencer goes offline during a sequence, the pending transactions must be handled gracefully. The system should include a watchdog mechanism that detects sequencer inactivity and triggers a manual or automated rollback of all in-flight sequences. This ensures that users are not left waiting indefinitely for a confirmation that will never arrive.
Testing Failure Scenarios
Before deploying cross-rollup sequencing in production, thoroughly test failure scenarios. Simulate network partitions, sequencer crashes, and state mismatches to ensure the rollback logic works as intended. Use automated testing frameworks to run these simulations repeatedly, verifying that the system always returns to a consistent state.
Verify latency and throughput gains
Before promoting your cross-rollup sequencing setup to production, you need to prove it performs better than isolated execution. The goal is to quantify the reduction in finality time and the increase in transactions per second (TPS) when using a shared sequencer versus independent rollup operators.
Benchmarking Latency
Set up a controlled test environment where identical transaction payloads are submitted to both your new cross-rollup architecture and a baseline isolated rollup. Measure the time delta between transaction submission and on-chain confirmation.
Focus on the "time-to-ordering" metric. In isolated systems, this includes the round-trip to the single sequencer. In cross-rollup setups, it should reflect the reduced queuing time due to shared liquidity and ordering. Use tools like web3.js or ethers.js to timestamp the sendTransaction call and the receipt.blockNumber arrival.
Measuring Throughput
Throughput isn't just about speed; it's about volume under load. Run a sustained stress test using a bot that submits transactions at a rate exceeding the typical capacity of a single rollup.
Monitor the rollup's L1 data availability submission rate. A successful cross-rollup implementation should show higher aggregate TPS across the coupled rollups without increasing L1 gas costs disproportionately. Compare this against the TPS of each rollup operating alone.
Comparison Baseline
Use this table to structure your internal performance review:
No comments yet. Be the first to share your thoughts!