feat: introduce BeaconProvider trait along with Mock implementation.

greged93 · greged93 · commit 8496196e81d3 · 2025-04-08T12:28:31.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -173,6 +173,7 @@ derive_more = { version = "2.0", default-features = false }
 eyre = "0.6"
 futures = { version = "0.3", default-features = false }
 rand = { version = "0.9" }
+reqwest = "0.12"
 secp256k1 = { version = "0.29", default-features = false }
 thiserror = "2.0"
 tokio = { version = "1.39", default-features = false }
diff --git a/bin/rollup/Cargo.toml b/bin/rollup/Cargo.toml
@@ -75,6 +75,7 @@ reth-tracing = { git = "https://github.com/scroll-tech/reth.git" }
 
 # misc
 futures.workspace = true
+reqwest.workspace = true
 serde_json = { version = "1.0.94", default-features = false, features = ["alloc"] }
 tokio = { workspace = true, features = ["full"] }
 
@@ -92,6 +93,7 @@ test-utils = [
     "rollup-node-watcher/test-utils",
     "scroll-db/test-utils",
     "scroll-db/test-utils",
+    "rollup-node-providers/test-utils",
 ]
 serde = [
     "alloy-primitives/serde",
diff --git a/bin/rollup/src/constants.rs b/bin/rollup/src/constants.rs
@@ -1,6 +1,9 @@
 /// The block number at which to start the L1 watcher.
 pub const WATCHER_START_BLOCK_NUMBER: u64 = 8000374;
 
+/// The size of the blob cache for the provider.
+pub const PROVIDER_BLOB_CACHE_SIZE: usize = 100;
+
 /// The max retries for the L1 provider.
 pub const PROVIDER_MAX_RETRIES: u32 = 10;
 
diff --git a/bin/rollup/src/network.rs b/bin/rollup/src/network.rs
@@ -12,7 +12,7 @@ use reth_scroll_primitives::ScrollPrimitives;
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
 use rollup_node_indexer::Indexer;
 use rollup_node_manager::{PoAConsensus, RollupNodeManager};
-use rollup_node_providers::{DatabaseL1MessageProvider, OnlineBeaconClient, OnlineL1Provider};
+use rollup_node_providers::{beacon_provider, DatabaseL1MessageProvider, OnlineL1Provider};
 use rollup_node_watcher::L1Watcher;
 use scroll_alloy_provider::ScrollAuthEngineApiProvider;
 use scroll_db::{Database, DatabaseConnectionProvider};
@@ -22,7 +22,10 @@ use scroll_wire::{ProtocolHandler, ScrollWireConfig};
 use std::sync::Arc;
 use tracing::info;
 
-use crate::{L1ProviderArgs, ScrollRollupNodeArgs, WATCHER_START_BLOCK_NUMBER};
+use crate::{
+    constants::PROVIDER_BLOB_CACHE_SIZE, L1ProviderArgs, ScrollRollupNodeArgs,
+    WATCHER_START_BLOCK_NUMBER,
+};
 
 /// The network builder for the eth-wire to scroll-wire bridge.
 #[derive(Debug)]
@@ -138,10 +141,12 @@ where
             None
         };
 
-        let beacon_client =
-            OnlineBeaconClient::new_http(l1_provider_args.beacon_rpc_url.to_string());
+        // Construct the l1 provider.
+        let beacon_provider = beacon_provider(l1_provider_args.beacon_rpc_url.to_string());
         let l1_messages_provider = DatabaseL1MessageProvider::new(db.clone());
-        let l1_provider = OnlineL1Provider::new(beacon_client, 100, l1_messages_provider).await;
+        let l1_provider =
+            OnlineL1Provider::new(beacon_provider, PROVIDER_BLOB_CACHE_SIZE, l1_messages_provider)
+                .await;
 
         // Spawn the rollup node manager
         let rollup_node_manager = RollupNodeManager::new(
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
@@ -62,6 +62,7 @@ test-utils = [
     "arbitrary",
     "dep:arbitrary",
     "reth-primitives/test-utils",
+    "rollup-node-providers/test-utils",
 ]
 serde = [
     "alloy-eips/serde",
diff --git a/crates/providers/Cargo.toml b/crates/providers/Cargo.toml
@@ -25,7 +25,7 @@ scroll-db.workspace = true
 async-trait.workspace = true
 auto_impl.workspace = true
 lru = "0.13.0"
-reqwest = { version = "0.12", features = ["json"] }
+reqwest = { workspace = true, features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 thiserror.workspace = true
 tokio = { workspace = true, default-features = false }
@@ -34,3 +34,6 @@ tokio = { workspace = true, default-features = false }
 eyre.workspace = true
 scroll-db = { workspace = true, features = ["test-utils"] }
 tokio = { workspace = true, features = ["macros"] }
+
+[features]
+test-utils = ["scroll-db/test-utils"]
diff --git a/crates/providers/src/beacon.rs b/crates/providers/src/beacon.rs
@@ -1,9 +1,41 @@
-//! Contains an implementation of a Beacon client.
+//! Exposes the [`BeaconProvider`] trait allowing to retrieve information from the Beacon chain.
 //! Credit to <https://github.com/op-rs/kona/tree/main/crates/providers/providers-alloy>
 
+use crate::L1ProviderError;
+use std::{format, sync::Arc, vec::Vec};
+
 use alloy_rpc_types_beacon::sidecar::{BeaconBlobBundle, BlobData};
 use reqwest::Client;
-use std::{format, vec::Vec};
+
+/// Returns a Beacon provider implementation, yielding a [`crate::test_utils::MockBeaconProvider`]
+/// when the test-utils feature is activated.
+pub fn beacon_provider(
+    _base: String,
+) -> Arc<dyn BeaconProvider<Error = reqwest::Error> + Send + Sync> {
+    #[cfg(feature = "test-utils")]
+    {
+        Arc::new(crate::test_utils::MockBeaconProvider::default())
+    }
+    #[cfg(not(feature = "test-utils"))]
+    {
+        Arc::new(OnlineBeaconClient::new_http(_base))
+    }
+}
+
+/// An implementation of the trait can provide information related to the Beacon chain.
+#[async_trait::async_trait]
+#[auto_impl::auto_impl(&, Arc)]
+pub trait BeaconProvider {
+    /// The error type for the provider.
+    type Error: Into<L1ProviderError> + std::fmt::Debug;
+
+    /// Returns the reduced configuration data for the Beacon client.
+    async fn config_spec(&self) -> Result<APIResponse<ReducedConfigData>, Self::Error>;
+    /// Returns the Beacon genesis information.
+    async fn beacon_genesis(&self) -> Result<APIResponse<ReducedGenesisData>, Self::Error>;
+    /// Returns the blobs for the provided slot.
+    async fn blobs(&self, slot: u64) -> Result<Vec<BlobData>, Self::Error>;
+}
 
 /// The config spec engine api method.
 const SPEC_METHOD: &str = "eth/v1/config/spec";
@@ -59,21 +91,24 @@ impl OnlineBeaconClient {
     }
 }
 
-impl OnlineBeaconClient {
+#[async_trait::async_trait]
+impl BeaconProvider for OnlineBeaconClient {
+    type Error = reqwest::Error;
+
     /// Returns the reduced configuration data for the Beacon client.
-    pub async fn config_spec(&self) -> Result<APIResponse<ReducedConfigData>, reqwest::Error> {
+    async fn config_spec(&self) -> Result<APIResponse<ReducedConfigData>, Self::Error> {
         let first = self.inner.get(format!("{}/{}", self.base, SPEC_METHOD)).send().await?;
         first.json::<APIResponse<ReducedConfigData>>().await
     }
 
     /// Returns the Beacon genesis information.
-    pub async fn beacon_genesis(&self) -> Result<APIResponse<ReducedGenesisData>, reqwest::Error> {
+    async fn beacon_genesis(&self) -> Result<APIResponse<ReducedGenesisData>, Self::Error> {
         let first = self.inner.get(format!("{}/{}", self.base, GENESIS_METHOD)).send().await?;
         first.json::<APIResponse<ReducedGenesisData>>().await
     }
 
     /// Returns the blobs for the provided slot.
-    pub async fn blobs(&self, slot: u64) -> Result<Vec<BlobData>, reqwest::Error> {
+    async fn blobs(&self, slot: u64) -> Result<Vec<BlobData>, Self::Error> {
         let raw_response = self
             .inner
             .get(format!("{}/{}/{}", self.base, SIDECARS_METHOD_PREFIX, slot))
@@ -93,6 +128,7 @@ mod tests {
     const BEACON_CLIENT_URL: &str = "https://eth-beacon-chain.drpc.org/rest/";
 
     #[tokio::test]
+    #[ignore]
     async fn test_should_return_genesis() -> eyre::Result<()> {
         let client = OnlineBeaconClient::new_http(BEACON_CLIENT_URL.to_string());
         let genesis = client.beacon_genesis().await?;
@@ -103,6 +139,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore]
     async fn test_should_return_config() -> eyre::Result<()> {
         let client = OnlineBeaconClient::new_http(BEACON_CLIENT_URL.to_string());
         let config = client.config_spec().await?;
diff --git a/crates/providers/src/l1/mod.rs b/crates/providers/src/l1/mod.rs
@@ -1,7 +1,7 @@
 pub(crate) mod blob;
 pub(crate) mod message;
 
-use crate::{beacon_client::OnlineBeaconClient, l1::message::L1MessageProvider, L1BlobProvider};
+use crate::{beacon::BeaconProvider, l1::message::L1MessageProvider, L1BlobProvider};
 use std::{num::NonZeroUsize, sync::Arc};
 
 use alloy_eips::eip4844::{Blob, BlobTransactionSidecarItem};
@@ -18,9 +18,9 @@ impl<T> L1Provider for T where T: L1BlobProvider + L1MessageProvider {}
 /// An error occurring at the [`L1Provider`].
 #[derive(Debug, thiserror::Error)]
 pub enum L1ProviderError {
-    /// Invalid timestamp for slot.
-    #[error("Beacon client error: {0}")]
-    BeaconClient(#[from] reqwest::Error),
+    /// Error at the beacon provider.
+    #[error("Beacon provider error: {0}")]
+    BeaconProvider(#[from] reqwest::Error),
     /// Invalid timestamp for slot.
     #[error("invalid block timestamp: genesis {0}, provided {1}")]
     InvalidBlockTimestamp(u64, u64),
@@ -34,37 +34,40 @@ pub enum L1ProviderError {
 
 /// An online implementation of the [`L1Provider`] trait.
 #[derive(Debug, Clone)]
-pub struct OnlineL1Provider<P> {
-    /// The Beacon client.
-    beacon_client: OnlineBeaconClient,
+pub struct OnlineL1Provider<L1P, BP> {
+    /// The beacon provider.
+    beacon_provider: BP,
     /// The cache for blobs from similar blocks.
     cache: Arc<Mutex<LruCache<B256, Arc<Blob>>>>,
     /// The L1 message provider
-    l1_message_provider: P,
+    l1_message_provider: L1P,
     /// The genesis timestamp for the Beacon chain.
     genesis_timestamp: u64,
     /// The slot interval for the Beacon chain.
     slot_interval: u64,
 }
 
-impl<P> OnlineL1Provider<P> {
+impl<L1P, BP> OnlineL1Provider<L1P, BP>
+where
+    BP: BeaconProvider,
+{
     /// Returns a new [`OnlineBeaconClient`] from the provided [`OnlineBeaconClient`], blob capacity
     /// and [`L1MessageProvider`].
-    pub async fn new(
-        client: OnlineBeaconClient,
-        blob_capacity: usize,
-        l1_message_provider: P,
-    ) -> Self {
+    pub async fn new(beacon_provider: BP, blob_capacity: usize, l1_message_provider: L1P) -> Self {
         let cache = Arc::new(Mutex::new(LruCache::new(
             NonZeroUsize::new(blob_capacity).expect("cache requires non-zero capacity"),
         )));
-        let config =
-            client.config_spec().await.expect("failed to fetch Beacon chain configuration");
-        let genesis =
-            client.beacon_genesis().await.expect("failed to fetch Beacon chain genesis info");
+        let config = beacon_provider
+            .config_spec()
+            .await
+            .expect("failed to fetch Beacon chain configuration");
+        let genesis = beacon_provider
+            .beacon_genesis()
+            .await
+            .expect("failed to fetch Beacon chain genesis info");
 
         Self {
-            beacon_client: client,
+            beacon_provider,
             cache,
             l1_message_provider,
             genesis_timestamp: genesis.data.genesis_time,
@@ -85,7 +88,7 @@ impl<P> OnlineL1Provider<P> {
 }
 
 #[async_trait::async_trait]
-impl<P: Sync> L1BlobProvider for OnlineL1Provider<P> {
+impl<L1P: Sync, BP: BeaconProvider + Sync> L1BlobProvider for OnlineL1Provider<L1P, BP> {
     /// Returns the requested blob corresponding to the passed hash.
     async fn blob(
         &self,
@@ -103,9 +106,10 @@ impl<P: Sync> L1BlobProvider for OnlineL1Provider<P> {
         // query the blobs with the client, return target blob and store all others in cache.
         let slot = self.slot(block_timestamp)?;
         let mut blobs = self
-            .beacon_client
+            .beacon_provider
             .blobs(slot)
-            .await?
+            .await
+            .map_err(Into::into)?
             .into_iter()
             .map(|blob| BlobTransactionSidecarItem {
                 index: blob.index,
@@ -134,8 +138,8 @@ impl<P: Sync> L1BlobProvider for OnlineL1Provider<P> {
 }
 
 #[async_trait::async_trait]
-impl<P: L1MessageProvider + Sync> L1MessageProvider for OnlineL1Provider<P> {
-    type Error = <P>::Error;
+impl<L1P: L1MessageProvider + Sync, BP: Sync> L1MessageProvider for OnlineL1Provider<L1P, BP> {
+    type Error = <L1P>::Error;
 
     async fn next_l1_message(&self) -> Result<Option<TxL1Message>, Self::Error> {
         self.l1_message_provider.next_l1_message().await
diff --git a/crates/providers/src/lib.rs b/crates/providers/src/lib.rs
@@ -1,8 +1,8 @@
 //! The crate exposes various Providers along with their implementations for usage across the rollup
 //! node.
 
-pub use beacon_client::OnlineBeaconClient;
-mod beacon_client;
+pub use beacon::{beacon_provider, BeaconProvider, OnlineBeaconClient};
+mod beacon;
 
 pub use execution_payload::ExecutionPayloadProvider;
 mod execution_payload;
@@ -13,3 +13,7 @@ pub use l1::{
     L1Provider, L1ProviderError, OnlineL1Provider,
 };
 mod l1;
+
+/// Test utils related to providers.
+#[cfg(feature = "test-utils")]
+pub mod test_utils;
diff --git a/crates/providers/src/test_utils.rs b/crates/providers/src/test_utils.rs
@@ -0,0 +1,28 @@
+use crate::{
+    beacon::{APIResponse, ReducedConfigData, ReducedGenesisData},
+    BeaconProvider,
+};
+
+use alloy_rpc_types_beacon::sidecar::BlobData;
+
+/// Mocks all calls to the beacon chain.
+#[derive(Debug, Default)]
+#[non_exhaustive]
+pub struct MockBeaconProvider;
+
+#[async_trait::async_trait]
+impl BeaconProvider for MockBeaconProvider {
+    type Error = reqwest::Error;
+
+    async fn config_spec(&self) -> Result<APIResponse<ReducedConfigData>, Self::Error> {
+        Ok(APIResponse { data: ReducedConfigData::default() })
+    }
+
+    async fn beacon_genesis(&self) -> Result<APIResponse<ReducedGenesisData>, Self::Error> {
+        Ok(APIResponse { data: ReducedGenesisData::default() })
+    }
+
+    async fn blobs(&self, _slot: u64) -> Result<Vec<BlobData>, Self::Error> {
+        Ok(vec![])
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ test-utils = [`
`62`	`62`	`"arbitrary",`
`63`	`63`	`"dep:arbitrary",`
`64`	`64`	`"reth-primitives/test-utils",`
	`65`	`+ "rollup-node-providers/test-utils",`
`65`	`66`	`]`
`66`	`67`	`serde = [`
`67`	`68`	`"alloy-eips/serde",`