Merge branch 'main' into feat/chain-orchestrator

Author: frisitano

.github/workflows/release.yml

@@ -29,7 +29,7 @@ jobs:
 
     - name: Extract docker metadata
       id: meta
-      uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
+      uses: docker/metadata-action@c1e51972afc2121e065aed6d45c65596fe445f3f # v5.8.0
       with:
         images: scrolltech/rollup-node
         tags: |

crates/node/src/add_ons/rollup.rs

@@ -6,7 +6,7 @@ use reth_network_api::FullNetwork;
 use reth_node_api::{FullNodeTypes, NodeTypes};
 use reth_node_builder::{rpc::RpcHandle, AddOnsContext, FullNodeComponents};
 use reth_rpc_eth_api::EthApiTypes;
-use reth_scroll_chainspec::ScrollChainSpec;
+use reth_scroll_chainspec::{ChainConfig, ScrollChainConfig, ScrollChainSpec};
 use reth_scroll_node::ScrollNetworkPrimitives;
 use rollup_node_manager::RollupManagerHandle;
 use rollup_node_watcher::L1Notification;
@@ -52,18 +52,13 @@ impl RollupManagerAddOn {
         rpc: RpcHandle<N, EthApi>,
     ) -> eyre::Result<(RollupManagerHandle, Option<Sender<Arc<L1Notification>>>)>
     where
-        <<N as FullNodeTypes>::Types as NodeTypes>::ChainSpec: ScrollHardforks + IsDevChain,
+        <<N as FullNodeTypes>::Types as NodeTypes>::ChainSpec:
+            ChainConfig<Config = ScrollChainConfig> + ScrollHardforks + IsDevChain,
         N::Network: NetworkProtocols + FullNetwork<Primitives = ScrollNetworkPrimitives>,
     {
         let (rnm, handle, l1_notification_tx) = self
             .config
-            .build(
-                ctx.node.network().clone(),
-                self.scroll_wire_event,
-                rpc.rpc_server_handles,
-                ctx.config.chain.clone(),
-                ctx.config.datadir().db(),
-            )
+            .build((&ctx).into(), self.scroll_wire_event, rpc.rpc_server_handles)
             .await?;
         ctx.node
             .task_executor()

crates/node/src/args.rs

@@ -1,6 +1,7 @@
 use crate::{
     add_ons::IsDevChain,
     constants::{self},
+    context::RollupNodeContext,
 };
 use std::{fs, path::PathBuf, sync::Arc, time::Duration};
 
@@ -17,7 +18,7 @@ use reth_network::NetworkProtocols;
 use reth_network_api::FullNetwork;
 use reth_node_builder::rpc::RethRpcServerHandles;
 use reth_node_core::primitives::BlockHeader;
-use reth_scroll_chainspec::SCROLL_FEE_VAULT_ADDRESS;
+use reth_scroll_chainspec::{ChainConfig, ScrollChainConfig, SCROLL_FEE_VAULT_ADDRESS};
 use reth_scroll_node::ScrollNetworkPrimitives;
 use rollup_node_chain_orchestrator::ChainOrchestrator;
 use rollup_node_manager::{
@@ -113,22 +114,11 @@ impl ScrollRollupNodeConfig {
 
 impl ScrollRollupNodeConfig {
     /// Consumes the [`ScrollRollupNodeConfig`] and builds a [`RollupNodeManager`].
-    pub async fn build<
-        N: FullNetwork<Primitives = ScrollNetworkPrimitives> + NetworkProtocols,
-        CS: ScrollHardforks
-            + EthChainSpec<Header: BlockHeader>
-            + IsDevChain
-            + Clone
-            + Send
-            + Sync
-            + 'static,
-    >(
+    pub async fn build<N, CS>(
         self,
-        network: N,
+        ctx: RollupNodeContext<N, CS>,
         events: UnboundedReceiver<ScrollWireEvent>,
         rpc_server_handles: RethRpcServerHandles,
-        chain_spec: CS,
-        db_path: PathBuf,
     ) -> eyre::Result<(
         RollupNodeManager<
             N,
@@ -140,11 +130,21 @@ impl ScrollRollupNodeConfig {
         >,
         RollupManagerHandle,
         Option<Sender<Arc<L1Notification>>>,
-    )> {
+    )>
+    where
+        N: FullNetwork<Primitives = ScrollNetworkPrimitives> + NetworkProtocols,
+        CS: EthChainSpec<Header: BlockHeader>
+            + ChainConfig<Config = ScrollChainConfig>
+            + ScrollHardforks
+            + IsDevChain
+            + 'static,
+    {
         tracing::info!(target: "rollup_node::args",
             "Building rollup node with config:\n{:#?}",
             self
         );
+        // Get the chain spec.
+        let chain_spec = ctx.chain_spec;
 
         // Get the rollup node config.
         let named_chain = chain_spec.chain().named().expect("expected named chain");
@@ -175,6 +175,7 @@ impl ScrollRollupNodeConfig {
         let l2_provider = Arc::new(l2_provider);
 
         // Instantiate the database
+        let db_path = ctx.datadir;
         let database_path = if let Some(database_path) = self.database_args.path {
             database_path.to_string_lossy().to_string()
         } else {
@@ -208,10 +209,10 @@ impl ScrollRollupNodeConfig {
         let eth_wire_listener = self
             .network_args
             .enable_eth_scroll_wire_bridge
-            .then_some(network.eth_wire_block_listener().await?);
+            .then_some(ctx.network.eth_wire_block_listener().await?);
         let scroll_network_manager = ScrollNetworkManager::from_parts(
             chain_spec.clone(),
-            network.clone(),
+            ctx.network.clone(),
             events,
             eth_wire_listener,
             self.network_args.eth_wire_gossip,
@@ -282,12 +283,14 @@ impl ScrollRollupNodeConfig {
         let l1_provider = FullL1Provider::new(blob_provider, l1_messages_provider.clone()).await;
 
         // Construct the Sequencer.
+        let chain_config = chain_spec.chain_config();
         let (sequencer, block_time) = if self.sequencer_args.sequencer_enabled {
             let args = &self.sequencer_args;
             let sequencer = Sequencer::new(
                 Arc::new(l1_messages_provider),
                 args.fee_recipient,
-                args.max_l1_messages_per_block,
+                ctx.block_gas_limit,
+                chain_config.l1_config.num_l1_messages_per_block,
                 0,
                 self.sequencer_args.l1_message_inclusion_mode,
             );
@@ -536,9 +539,6 @@ pub struct SequencerArgs {
     /// The payload building duration for the sequencer (milliseconds)
     #[arg(long = "sequencer.payload-building-duration", id = "sequencer_payload_building_duration", value_name = "SEQUENCER_PAYLOAD_BUILDING_DURATION", default_value_t = constants::DEFAULT_PAYLOAD_BUILDING_DURATION)]
     pub payload_building_duration: u64,
-    /// The max L1 messages per block for the sequencer.
-    #[arg(long = "sequencer.max-l1-messages-per-block", id = "sequencer_max_l1_messages_per_block", value_name = "SEQUENCER_MAX_L1_MESSAGES_PER_BLOCK", default_value_t = constants::DEFAULT_MAX_L1_MESSAGES_PER_BLOCK)]
-    pub max_l1_messages_per_block: u64,
     /// The fee recipient for the sequencer.
     #[arg(long = "sequencer.fee-recipient", id = "sequencer_fee_recipient", value_name = "SEQUENCER_FEE_RECIPIENT", default_value_t = SCROLL_FEE_VAULT_ADDRESS)]
     pub fee_recipient: Address,

crates/node/src/constants.rs

@@ -1,3 +1,5 @@
+//! Constants related to the [`crate::ScrollRollupNode`]
+
 /// The max retries for the L1 provider.
 pub(crate) const PROVIDER_MAX_RETRIES: u32 = 10;
 
@@ -16,9 +18,6 @@ pub(crate) const DEFAULT_PAYLOAD_BUILDING_DURATION: u64 = 800;
 /// The default payload size limit in bytes for the sequencer.
 pub(crate) const DEFAULT_PAYLOAD_SIZE_LIMIT: u64 = 122_880;
 
-/// The default max L1 messages per block for the sequencer.
-pub(crate) const DEFAULT_MAX_L1_MESSAGES_PER_BLOCK: u64 = 4;
-
 /// The gap in blocks between the P2P and EN which triggers sync.
 pub(crate) const BLOCK_GAP_TRIGGER: u64 = 100_000;
 
@@ -27,3 +26,7 @@ pub(crate) const CHAIN_BUFFER_SIZE: usize = 2000;
 
 /// The default suggested priority fee for the gas price oracle.
 pub(crate) const DEFAULT_SUGGEST_PRIORITY_FEE: u64 = 100;
+
+/// Scroll default gas limit.
+/// Should match <https://github.com/scroll-tech/reth/blob/scroll/crates/scroll/node/src/builder/payload.rs#L36>.
+pub const SCROLL_GAS_LIMIT: u64 = 20_000_000;

crates/node/src/context.rs

@@ -0,0 +1,45 @@
+use crate::constants::SCROLL_GAS_LIMIT;
+use reth_node_api::{AddOnsContext, FullNodeComponents, FullNodeTypes};
+use reth_node_core::cli::config::PayloadBuilderConfig;
+use reth_node_types::NodeTypes;
+use std::{path::PathBuf, sync::Arc};
+
+/// The context passed to `ScrollRollupNodeConfig::build` method.
+#[derive(Debug)]
+pub struct RollupNodeContext<N, CS> {
+    /// The network component of the rollup node.
+    pub network: N,
+    /// The chain specification of the rollup node.
+    pub chain_spec: Arc<CS>,
+    /// The datadir of the rollup node.
+    pub datadir: PathBuf,
+    /// The block gas limit of the rollup node.
+    pub block_gas_limit: u64,
+}
+
+impl<N, CS> RollupNodeContext<N, CS> {
+    /// Returns a new instance of the [`RollupNodeContext`].
+    pub const fn new(
+        network: N,
+        chain_spec: Arc<CS>,
+        datadir: PathBuf,
+        block_gas_limit: u64,
+    ) -> Self {
+        Self { network, chain_spec, datadir, block_gas_limit }
+    }
+}
+
+impl<N> From<&AddOnsContext<'_, N>>
+    for RollupNodeContext<N::Network, <<N as FullNodeTypes>::Types as NodeTypes>::ChainSpec>
+where
+    N: FullNodeComponents,
+{
+    fn from(value: &AddOnsContext<'_, N>) -> Self {
+        Self {
+            network: value.node.network().clone(),
+            chain_spec: value.config.chain.clone(),
+            datadir: value.config.datadir().db(),
+            block_gas_limit: value.config.builder.gas_limit().unwrap_or(SCROLL_GAS_LIMIT),
+        }
+    }
+}

crates/node/src/lib.rs

@@ -2,10 +2,12 @@
 
 pub mod add_ons;
 mod args;
-mod constants;
+pub mod constants;
+mod context;
 mod node;
 #[cfg(feature = "test-utils")]
 pub mod test_utils;
 
 pub use args::*;
+pub use context::RollupNodeContext;
 pub use node::ScrollRollupNode;

crates/node/src/main.rs

@@ -23,6 +23,8 @@ fn main() {
             let handle = builder
                 .node(ScrollRollupNode::new(args))
                 .launch_with_fn(|builder| {
+                    info!(target: "reth::cli", config = ?builder.config().chain.config, "Running with config");
+
                     // We must use `always_process_payload_attributes_on_canonical_head` in order to
                     // be able to build payloads with the forkchoice state API
                     // on top of heads part of the canonical state. Not

crates/node/src/test_utils.rs

@@ -176,7 +176,6 @@ pub fn default_sequencer_test_scroll_rollup_node_config() -> ScrollRollupNodeCon
             sequencer_enabled: true,
             block_time: 50,
             payload_building_duration: 40,
-            max_l1_messages_per_block: 0,
             fee_recipient: Default::default(),
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
         },

crates/node/tests/e2e.rs

@@ -13,13 +13,14 @@ use reth_scroll_chainspec::SCROLL_DEV;
 use reth_scroll_node::ScrollNetworkPrimitives;
 use reth_tokio_util::EventStream;
 use rollup_node::{
+    constants::SCROLL_GAS_LIMIT,
     test_utils::{
         default_sequencer_test_scroll_rollup_node_config, default_test_scroll_rollup_node_config,
         generate_tx, setup_engine,
     },
     BeaconProviderArgs, ChainOrchestratorArgs, ConsensusAlgorithm, ConsensusArgs, DatabaseArgs,
     EngineDriverArgs, GasPriceOracleArgs, L1ProviderArgs, NetworkArgs as ScrollNetworkArgs,
-    ScrollRollupNodeConfig, SequencerArgs,
+    RollupNodeContext, ScrollRollupNodeConfig, SequencerArgs,
 };
 use rollup_node_chain_orchestrator::ChainOrchestratorEvent;
 use rollup_node_manager::{RollupManagerCommand, RollupManagerEvent, RollupManagerHandle};
@@ -50,7 +51,6 @@ async fn can_bridge_l1_messages() -> eyre::Result<()> {
         sequencer_args: SequencerArgs {
             sequencer_enabled: true,
             block_time: 0,
-            max_l1_messages_per_block: 4,
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
             ..SequencerArgs::default()
         },
@@ -146,7 +146,6 @@ async fn can_sequence_and_gossip_blocks() {
         sequencer_args: SequencerArgs {
             sequencer_enabled: true,
             block_time: 0,
-            max_l1_messages_per_block: 4,
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
             payload_building_duration: 1000,
             ..SequencerArgs::default()
@@ -587,11 +586,14 @@ async fn graceful_shutdown_consolidates_most_recent_batch_on_startup() -> eyre::
     let (rnm, handle, l1_notification_tx) = config
         .clone()
         .build(
-            node.inner.network.clone(),
+            RollupNodeContext::new(
+                node.inner.network.clone(),
+                chain_spec.clone(),
+                path.clone(),
+                SCROLL_GAS_LIMIT,
+            ),
             events,
             node.inner.add_ons_handle.rpc_handle.rpc_server_handles.clone(),
-            chain_spec.clone(),
-            path.clone(),
         )
         .await?;
 
@@ -694,11 +696,14 @@ async fn graceful_shutdown_consolidates_most_recent_batch_on_startup() -> eyre::
     let (rnm, handle, l1_notification_tx) = config
         .clone()
         .build(
-            node.inner.network.clone(),
+            RollupNodeContext::new(
+                node.inner.network.clone(),
+                chain_spec,
+                path.clone(),
+                SCROLL_GAS_LIMIT,
+            ),
             events,
             node.inner.add_ons_handle.rpc_handle.rpc_server_handles.clone(),
-            chain_spec,
-            path.clone(),
         )
         .await?;
     let l1_notification_tx = l1_notification_tx.unwrap();
@@ -876,7 +881,6 @@ async fn can_handle_reorgs_while_sequencing() -> eyre::Result<()> {
             .expect("valid url that will not be used as test batches use calldata"),
     );
     config.engine_driver_args.sync_at_startup = false;
-    config.sequencer_args.max_l1_messages_per_block = 1;
     let (mut nodes, _tasks, _) = setup_engine(config, 1, chain_spec.clone(), false, false).await?;
     let node = nodes.pop().unwrap();
 

crates/node/tests/sync.rs

@@ -195,7 +195,6 @@ async fn test_should_consolidate_after_optimistic_sync() -> eyre::Result<()> {
         sequencer_args: SequencerArgs {
             sequencer_enabled: true,
             block_time: 0,
-            max_l1_messages_per_block: 4,
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
             ..SequencerArgs::default()
         },
@@ -444,7 +443,6 @@ async fn test_consolidation() -> eyre::Result<()> {
         sequencer_args: SequencerArgs {
             sequencer_enabled: true,
             block_time: 0,
-            max_l1_messages_per_block: 4,
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
             ..SequencerArgs::default()
         },
@@ -617,7 +615,6 @@ async fn test_chain_orchestrator_shallow_reorg_with_gap() -> eyre::Result<()> {
         sequencer_args: SequencerArgs {
             sequencer_enabled: true,
             block_time: 0,
-            max_l1_messages_per_block: 4,
             l1_message_inclusion_mode: L1MessageInclusionMode::BlockDepth(0),
             ..SequencerArgs::default()
         },