Merge branch 'main' into e2e-test-integrate-l2geth

Author: colinlyguo

Cargo.lock

@@ -155,7 +155,6 @@ reth-primitives-traits = { git = "https://github.com/scroll-tech/reth.git", defa
 reth-provider = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-rpc-builder = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-rpc-server-types = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
-reth-storage-api = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-tasks = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-tokio-util = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-tracing = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
@@ -207,5 +206,5 @@ tracing = "0.1.0"
 getrandom = { version = "0.2", features = ["js"] }
 
 [patch.crates-io]
-revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
-op-revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm = { git = "https://github.com/scroll-tech/revm" }
+op-revm = { git = "https://github.com/scroll-tech/revm" }

Cargo.toml

@@ -17,7 +17,7 @@ reth-network-api.workspace = true
 reth-network-types = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 reth-network-peers.workspace = true
 reth-primitives-traits.workspace = true
-reth-storage-api = { workspace = true, default-features = false }
+reth-storage-api = { git = "https://github.com/scroll-tech/reth.git", default-features = false }
 
 # scroll
 reth-scroll-chainspec.workspace = true

crates/network/Cargo.toml

@@ -4,8 +4,9 @@ use super::{
     BlockImportOutcome, BlockValidation, NetworkHandleMessage, NetworkManagerEvent,
     NewBlockWithPeer, ScrollNetworkHandle,
 };
-use alloy_primitives::FixedBytes;
+use alloy_primitives::{FixedBytes, U128};
 use futures::{FutureExt, Stream, StreamExt};
+use reth_eth_wire_types::NewBlock as EthWireNewBlock;
 use reth_network::{
     cache::LruCache, NetworkConfig as RethNetworkConfig, NetworkHandle as RethNetworkHandle,
     NetworkManager as RethNetworkManager,
@@ -77,7 +78,7 @@ impl ScrollNetworkManager<RethNetworkHandle<ScrollNetworkPrimitives>> {
     }
 }
 
-impl<N: FullNetwork> ScrollNetworkManager<N> {
+impl<N: FullNetwork<Primitives = ScrollNetworkPrimitives>> ScrollNetworkManager<N> {
     /// Creates a new [`ScrollNetworkManager`] instance from the provided parts.
     ///
     /// This is used when the scroll-wire [`ScrollWireProtocolHandler`] and the inner network
@@ -117,6 +118,14 @@ impl<N: FullNetwork> ScrollNetworkManager<N> {
             .filter_map(|(peer_id, blocks)| (!blocks.contains(&hash)).then_some(*peer_id))
             .collect();
 
+        let eth_wire_new_block = {
+            let td = U128::from_limbs([0, block.block.header.number]);
+            let mut eth_wire_block = block.block.clone();
+            eth_wire_block.header.extra_data = block.signature.clone().into();
+            EthWireNewBlock { block: eth_wire_block, td }
+        };
+        self.inner_network_handle().eth_wire_announce_block(eth_wire_new_block, hash);
+
         // Announce block to the filtered set of peers
         for peer_id in peers {
             trace!(target: "scroll::network::manager", peer_id = %peer_id, block_hash = %hash, "Announcing new block to peer");
@@ -184,7 +193,7 @@ impl<N: FullNetwork> ScrollNetworkManager<N> {
     }
 }
 
-impl<N: FullNetwork> Stream for ScrollNetworkManager<N> {
+impl<N: FullNetwork<Primitives = ScrollNetworkPrimitives>> Stream for ScrollNetworkManager<N> {
     type Item = NetworkManagerEvent;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {

crates/network/src/manager.rs

@@ -1,14 +1,16 @@
 //! The [`ScrollRollupNodeAddOns`] implementation for the Scroll rollup node.
 
 use super::args::ScrollRollupNodeConfig;
+use crate::constants;
+
 use reth_evm::{ConfigureEvm, EvmFactory, EvmFactoryFor};
 use reth_network::NetworkProtocols;
 use reth_network_api::FullNetwork;
 use reth_node_api::{AddOnsContext, NodeAddOns};
 use reth_node_builder::{
     rpc::{
         BasicEngineApiBuilder, EngineValidatorAddOn, EngineValidatorBuilder, EthApiBuilder,
-        RethRpcAddOns, RpcAddOns, RpcHandle,
+        Identity, RethRpcAddOns, RethRpcMiddleware, RpcAddOns,
     },
     FullNodeComponents,
 };
@@ -22,7 +24,7 @@ use reth_scroll_node::{
     ScrollEngineValidator, ScrollEngineValidatorBuilder, ScrollNetworkPrimitives, ScrollStorage,
 };
 use reth_scroll_primitives::ScrollPrimitives;
-use reth_scroll_rpc::{eth::ScrollEthApiBuilder, ScrollEthApi, ScrollEthApiError};
+use reth_scroll_rpc::{eth::ScrollEthApiBuilder, ScrollEthApiError};
 use scroll_alloy_evm::ScrollTransactionIntoTxEnv;
 use scroll_wire::ScrollWireEvent;
 
@@ -36,7 +38,7 @@ use tokio::sync::mpsc::UnboundedReceiver;
 
 /// Add-ons for the Scroll follower node.
 #[derive(Debug)]
-pub struct ScrollRollupNodeAddOns<N>
+pub struct ScrollRollupNodeAddOns<N, RpcMiddleware = Identity>
 where
     N: FullNodeComponents,
     ScrollEthApiBuilder: EthApiBuilder<N>,
@@ -48,6 +50,7 @@ where
         ScrollEthApiBuilder,
         ScrollEngineValidatorBuilder,
         BasicEngineApiBuilder<ScrollEngineValidatorBuilder>,
+        RpcMiddleware,
     >,
 
     /// Rollup manager addon responsible for managing the components of the rollup node.
@@ -65,16 +68,33 @@ where
     ) -> Self {
         let rpc_add_ons = RpcAddOns::new(
             ScrollEthApiBuilder::default()
+                .with_min_suggested_priority_fee(
+                    config.gas_price_oracle_args.default_suggested_priority_fee,
+                )
+                .with_payload_size_limit(constants::DEFAULT_PAYLOAD_SIZE_LIMIT)
                 .with_sequencer(config.network_args.sequencer_url.clone()),
             Default::default(),
             Default::default(),
-            Default::default(),
+            Identity::new(),
         );
         let rollup_manager_addon = RollupManagerAddOn::new(config, scroll_wire_event);
         Self { rpc_add_ons, rollup_manager_addon }
     }
 }
-impl<N> NodeAddOns<N> for ScrollRollupNodeAddOns<N>
+
+impl<N, RpcMiddleware> ScrollRollupNodeAddOns<N, RpcMiddleware>
+where
+    N: FullNodeComponents,
+    ScrollEthApiBuilder: EthApiBuilder<N>,
+{
+    /// Sets the provided middleware for the rollup node addons.
+    pub fn with_middleware<T>(self, middleware: T) -> ScrollRollupNodeAddOns<N, T> {
+        let rpc_add_ons = self.rpc_add_ons.with_rpc_middleware(middleware);
+        ScrollRollupNodeAddOns { rpc_add_ons, rollup_manager_addon: self.rollup_manager_addon }
+    }
+}
+
+impl<N, RpcMiddleware> NodeAddOns<N> for ScrollRollupNodeAddOns<N, RpcMiddleware>
 where
     N: FullNodeComponents<
         Types: NodeTypes<
@@ -88,16 +108,13 @@ where
     >,
     ScrollEthApiError: FromEvmError<N::Evm>,
     EvmFactoryFor<N::Evm>: EvmFactory<Tx = ScrollTransactionIntoTxEnv<TxEnv>>,
+    RpcMiddleware: RethRpcMiddleware,
 {
-    type Handle = ScrollAddOnsHandle<N, ScrollEthApi<N>>;
+    type Handle = ScrollAddOnsHandle<N, <ScrollEthApiBuilder as EthApiBuilder<N>>::EthApi>;
 
-    async fn launch_add_ons(
-        self,
-        ctx: reth_node_api::AddOnsContext<'_, N>,
-    ) -> eyre::Result<Self::Handle> {
+    async fn launch_add_ons(self, ctx: AddOnsContext<'_, N>) -> eyre::Result<Self::Handle> {
         let Self { rpc_add_ons, rollup_manager_addon: rollup_node_manager_addon } = self;
-        let rpc_handle: RpcHandle<N, ScrollEthApi<N>> =
-            rpc_add_ons.launch_add_ons_with(ctx.clone(), |_| Ok(())).await?;
+        let rpc_handle = rpc_add_ons.launch_add_ons_with(ctx.clone(), |_| Ok(())).await?;
         let (rollup_manager_handle, l1_watcher_tx) =
             rollup_node_manager_addon.launch(ctx.clone(), rpc_handle.clone()).await?;
         Ok(ScrollAddOnsHandle {
@@ -109,7 +126,7 @@ where
     }
 }
 
-impl<N> RethRpcAddOns<N> for ScrollRollupNodeAddOns<N>
+impl<N, RpcMiddleware> RethRpcAddOns<N> for ScrollRollupNodeAddOns<N, RpcMiddleware>
 where
     N: FullNodeComponents<
         Types: NodeTypes<
@@ -123,8 +140,9 @@ where
     >,
     ScrollEthApiError: FromEvmError<N::Evm>,
     EvmFactoryFor<N::Evm>: EvmFactory<Tx = ScrollTransactionIntoTxEnv<TxEnv>>,
+    RpcMiddleware: RethRpcMiddleware,
 {
-    type EthApi = ScrollEthApi<N>;
+    type EthApi = <ScrollEthApiBuilder as EthApiBuilder<N>>::EthApi;
 
     fn hooks_mut(&mut self) -> &mut reth_node_builder::rpc::RpcHooks<N, Self::EthApi> {
         self.rpc_add_ons.hooks_mut()

crates/node/src/add_ons/mod.rs

@@ -66,6 +66,9 @@ pub struct ScrollRollupNodeConfig {
     /// The signer arguments
     #[command(flatten)]
     pub signer_args: SignerArgs,
+    /// The gas price oracle args
+    #[command(flatten)]
+    pub gas_price_oracle_args: GasPriceOracleArgs,
 }
 
 impl ScrollRollupNodeConfig {
@@ -483,6 +486,15 @@ impl SignerArgs {
     }
 }
 
+/// The arguments for the sequencer.
+#[derive(Debug, Default, Clone, clap::Args)]
+pub struct GasPriceOracleArgs {
+    /// Minimum suggested priority fee (tip) in wei, default `100`
+    #[arg(long, default_value_t = 100)]
+    #[arg(long = "gpo.default-suggest-priority-fee", id = "default_suggest_priority_fee", value_name = "DEFAULT_SUGGEST_PRIORITY_FEE", default_value_t = constants::DEFAULT_SUGGEST_PRIORITY_FEE)]
+    pub default_suggested_priority_fee: u64,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -499,6 +511,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         let result = config.validate();
@@ -522,6 +535,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         let result = config.validate();
@@ -545,6 +559,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         assert!(config.validate().is_ok());
@@ -561,6 +576,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         assert!(config.validate().is_ok());
@@ -577,6 +593,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         assert!(config.validate().is_ok());
@@ -593,6 +610,7 @@ mod tests {
             l1_provider_args: L1ProviderArgs::default(),
             beacon_provider_args: BeaconProviderArgs::default(),
             network_args: NetworkArgs::default(),
+            gas_price_oracle_args: GasPriceOracleArgs::default(),
         };
 
         assert!(config.validate().is_ok());

crates/node/src/args.rs

@@ -21,3 +21,6 @@ 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 = 500_000;
+
+/// The default suggested priority fee for the gas price oracle.
+pub(crate) const DEFAULT_SUGGEST_PRIORITY_FEE: u64 = 100;

crates/node/src/constants.rs

@@ -17,8 +17,8 @@ fn main() {
         std::env::set_var("RUST_BACKTRACE", "1");
     }
 
-    if let Err(err) = Cli::<ScrollChainSpecParser, ScrollRollupNodeConfig>::parse()
-        .run::<_, _, ScrollRollupNode>(|builder, args| async move {
+    if let Err(err) = Cli::<ScrollChainSpecParser, ScrollRollupNodeConfig>::parse().run(
+        |builder, args| async move {
             info!(target: "reth::cli", "Launching node");
             let handle = builder
                 .node(ScrollRollupNode::new(args))
@@ -42,8 +42,8 @@ fn main() {
                 })
                 .await?;
             handle.node_exit_future.await
-        })
-    {
+        },
+    ) {
         eprintln!("Error: {err:?}");
         std::process::exit(1);
     }

crates/node/src/main.rs

@@ -1,5 +1,7 @@
 //! This crate contains utilities for running end-to-end tests for the scroll reth node.
 
+use crate::GasPriceOracleArgs;
+
 use super::{
     BeaconProviderArgs, DatabaseArgs, EngineDriverArgs, L1ProviderArgs, ScrollRollupNode,
     ScrollRollupNodeConfig, SequencerArgs,
@@ -149,6 +151,7 @@ pub fn default_test_scroll_rollup_node_config() -> ScrollRollupNodeConfig {
             ..Default::default()
         },
         signer_args: Default::default(),
+        gas_price_oracle_args: GasPriceOracleArgs::default(),
     }
 }
 
@@ -173,5 +176,6 @@ pub fn default_sequencer_test_scroll_rollup_node_config() -> ScrollRollupNodeCon
             ..Default::default()
         },
         signer_args: Default::default(),
+        gas_price_oracle_args: GasPriceOracleArgs::default(),
     }
 }