feat: limit l1 messages included up to block gas limit (#238)

* feat: add RollupNodeContext

* feat: add cumulative gas used l1 messages predicate

Author: greged93

crates/node/src/add_ons/rollup.rs

@@ -57,13 +57,7 @@ impl RollupManagerAddOn {
     {
         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};
 
@@ -109,22 +110,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,
@@ -136,14 +126,22 @@ impl ScrollRollupNodeConfig {
         >,
         RollupManagerHandle,
         Option<Sender<Arc<L1Notification>>>,
-    )> {
+    )>
+    where
+        N: FullNetwork<Primitives = ScrollNetworkPrimitives> + NetworkProtocols,
+        CS: EthChainSpec<Header: BlockHeader> + ScrollHardforks + IsDevChain + 'static,
+    {
         tracing::info!(target: "rollup_node::args",
             "Building rollup node with config:\n{:#?}",
             self
         );
         // Instantiate the network manager
+        let network = ctx.network;
         let scroll_network_manager = ScrollNetworkManager::from_parts(network.clone(), events);
 
+        // 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");
         let node_config = Arc::new(NodeConfig::from_named_chain(named_chain));
@@ -173,6 +171,7 @@ impl ScrollRollupNodeConfig {
             .expect("failed to create payload 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 {
@@ -273,6 +272,7 @@ impl ScrollRollupNodeConfig {
             let sequencer = Sequencer::new(
                 Arc::new(l1_messages_provider),
                 args.fee_recipient,
+                ctx.block_gas_limit,
                 args.max_l1_messages_per_block,
                 0,
                 self.sequencer_args.l1_message_inclusion_mode,

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;
 
@@ -24,3 +26,7 @@ pub(crate) const BLOCK_GAP_TRIGGER: u64 = 500_000;
 
 /// 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/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, ConsensusAlgorithm, ConsensusArgs, DatabaseArgs, EngineDriverArgs,
-    GasPriceOracleArgs, L1ProviderArgs, NetworkArgs as ScrollNetworkArgs, ScrollRollupNodeConfig,
-    SequencerArgs,
+    GasPriceOracleArgs, L1ProviderArgs, NetworkArgs as ScrollNetworkArgs, RollupNodeContext,
+    ScrollRollupNodeConfig, SequencerArgs,
 };
 use rollup_node_manager::{RollupManagerCommand, RollupManagerEvent, RollupManagerHandle};
 use rollup_node_primitives::{sig_encode_hash, BatchCommitData, ConsensusUpdate};
@@ -497,11 +498,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?;
 
@@ -604,11 +608,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();
@@ -695,11 +702,14 @@ async fn can_handle_batch_revert() -> eyre::Result<()> {
     let (rnm, handle, l1_watcher_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?;
     let l1_watcher_tx = l1_watcher_tx.unwrap();
@@ -827,11 +837,14 @@ async fn can_handle_reorgs_while_sequencing() -> eyre::Result<()> {
     let (rnm, handle, l1_watcher_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?;
     let l1_watcher_tx = l1_watcher_tx.unwrap();