add docker compose tests

Author: frisitano

crates/node/src/args.rs

@@ -923,7 +923,7 @@ pub struct RemoteBlockSourceArgs {
     pub enabled: bool,
 
     /// URL for the remote L2 source node RPC
-    #[arg(long = "remote-source.url", value_name = "URL")]
+    #[arg(long = "remote-source.url", id = "remote_source_url", value_name = "URL")]
     pub url: Option<reqwest::Url>,
 
     /// Polling interval in milliseconds (when already synced)

tests/docker-compose.remote-source.yml

@@ -0,0 +1,72 @@
+services:
+  l1-node:
+    image: ghcr.io/foundry-rs/foundry:v1.2.3
+    entrypoint: ["bash", "/launch_l1.bash"]
+    ports:
+      - "8544:8545"
+    volumes:
+      - ./launch_l1.bash:/launch_l1.bash:ro
+      - ./anvil.env:/anvil.env:ro
+      - ./anvil_state.json:/anvil_state.json:ro
+    healthcheck:
+      test: ["CMD", "bash", "-c", "[ \"$(cast storage 0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0 0x67 --rpc-url http://localhost:8545)\" = \"0x000000000000000000000000b674ff99cca262c99d3eab5b32796a99188543da\" ]"]
+      interval: 3s
+      timeout: 10s
+      retries: 30
+      start_period: 0s
+
+  rollup-node-sequencer:
+    build:
+      context: ../
+      dockerfile: Dockerfile.test
+    entrypoint: ["bash", "/launch_rollup_node_sequencer.bash"]
+    environment:
+      - RUST_LOG=info
+    ports:
+      - "8545:8545"   # JSON-RPC
+      - "6060:6060"   # Metrics
+    volumes:
+      - ./launch_rollup_node_sequencer.bash:/launch_rollup_node_sequencer.bash:ro
+      - ./l2reth-genesis-e2e.json:/l2reth/l2reth-genesis-e2e.json:ro
+      - l2reth-sequencer:/l2reth
+    depends_on:
+      l1-node:
+        condition: service_healthy
+
+  rollup-node-remote-source:
+    build:
+      context: ../
+      dockerfile: Dockerfile.test
+    entrypoint: ["bash", "/launch_rollup_node_remote_source.bash"]
+    environment:
+      - RUST_LOG=info
+    ports:
+      - "8546:8545"   # JSON-RPC
+      - "6061:6060"   # Metrics
+    volumes:
+      - ./launch_rollup_node_remote_source.bash:/launch_rollup_node_remote_source.bash:ro
+      - ./l2reth-genesis-e2e.json:/l2reth/l2reth-genesis-e2e.json:ro
+      - l2reth-remote-source:/l2reth
+    depends_on:
+      l1-node:
+        condition: service_healthy
+
+  l2geth-skipsignercheck:
+    image: scrolltech/l2geth:scroll-v5.10.2-skip-signer-check
+    platform: linux/amd64
+    entrypoint: ["bash", "/launch_l2geth_skipsignercheck.bash"]
+    ports:
+      - "8547:8545"    # JSON-RPC
+      - "6062:6060"    # Metrics
+    volumes:
+      - ./l2geth-genesis-e2e.json:/l2geth-genesis-e2e.json:ro
+      - ./launch_l2geth_skipsignercheck.bash:/launch_l2geth_skipsignercheck.bash:ro
+      - l2geth-skipsignercheck:/l2geth
+    depends_on:
+      l1-node:
+        condition: service_healthy
+
+volumes:
+  l2reth-sequencer:
+  l2reth-remote-source:
+  l2geth-skipsignercheck:

tests/launch_l2geth_skipsignercheck.bash

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+
+geth init --datadir=/l2geth /l2geth-genesis-e2e.json
+
+echo "Starting l2geth with skip signer check..."
+exec geth --datadir=/l2geth \
+  --port 30303 --syncmode full --networkid 938471 --nodiscover \
+  --http --http.addr 0.0.0.0 --http.port 8545 --http.vhosts "*" --http.corsdomain "*" --http.api "admin,eth,scroll,net,web3,debug" \
+  --ws --ws.addr 0.0.0.0 --ws.port 8546 --ws.api "admin,eth,scroll,net,web3,debug" \
+  --pprof --pprof.addr 0.0.0.0 --pprof.port 6060 --metrics --verbosity 5 --log.debug \
+  --l1.endpoint "http://l1-node:8545" --l1.confirmations finalized --l1.sync.startblock 0 --l1.sync.interval 1s \
+  --gcmode archive --cache.noprefetch --cache.snapshot=0 --snapshot=false \
+  --gossip.enablebroadcasttoall \
+  --nat extip:0.0.0.0 \
+  --skipsignercheck

tests/launch_rollup_node_remote_source.bash

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -e
+
+# Prepare signer key
+echo -n "0xd510c4b7c61a604f800c4f06803b1ee14b9a63de345e53426ae50425f2dbb058" > /l2reth/sequencer-key
+
+# Prepare node key for the remote source node to have a predictable enode URL
+echo -n "53b69b913cb8c64a3ae83bf0ffb1e9e9efa80d7e1924dd076a8d2b1482f1b21b" > /l2reth/nodekey
+# -> enode://849431bd98c23f8203cf475cfd8efb980d1e2af46337141cfb7dd960d4ae6f8c489846da293305705c8918fbf991e41805afc8c7231c96f3f938120b6826affc@rollup-node-remote-source:30303
+
+export RUST_LOG=sqlx=off,scroll=trace,reth=info,rollup=trace,info
+
+exec rollup-node node --chain /l2reth/l2reth-genesis-e2e.json --datadir=/l2reth --metrics=0.0.0.0:6060 \
+  --disable-discovery \
+  --network.valid_signer "0xb674ff99cca262c99d3eab5b32796a99188543da" \
+  --http --http.addr=0.0.0.0 --http.port=8545 --http.corsdomain "*" --http.api admin,debug,eth,net,trace,txpool,web3,rpc,reth,ots,flashbots,miner,mev \
+  --ws --ws.addr=0.0.0.0 --ws.port=8546 --ws.api admin,debug,eth,net,trace,txpool,web3,rpc,reth,ots,flashbots,miner,mev \
+  --rpc.rollup-node-admin \
+  --log.stdout.format log-fmt -vvv \
+  --sequencer.enabled \
+  --sequencer.allow-empty-blocks \
+  --signer.key-file /l2reth/sequencer-key \
+  --sequencer.block-time 500 \
+  --sequencer.payload-building-duration 400 \
+  --txpool.pending-max-count=1000 \
+  --builder.gaslimit=30000000 \
+  --rpc.max-connections=5000 \
+  --p2p-secret-key /l2reth/nodekey \
+  --engine.sync-at-startup false \
+  --remote-source.enabled \
+  --remote-source.url http://rollup-node-sequencer:8545 \
+  --remote-source.poll-interval-ms 100 \
+  --l1.url http://l1-node:8545 \
+  --blob.mock

tests/src/docker_compose.rs

@@ -43,9 +43,17 @@ const RN_FOLLOWER_RPC_URL: &str = "http://localhost:8546";
 /// The l2geth node RPC URL for the Docker Compose environment.
 const L2GETH_SEQUENCER_RPC_URL: &str = "http://localhost:8547";
 
+/// The l2geth follower node RPC URL for the Docker Compose environment.
 const L2GETH_FOLLOWER_RPC_URL: &str = "http://localhost:8548";
 
-const RN_SEQUENCER_ENODE: &str= "enode://e7f7e271f62bd2b697add14e6987419758c97e83b0478bd948f5f2d271495728e7edef5bd78ad65258ac910f28e86928ead0c42ee51f2a0168d8ca23ba939766@{IP}:30303";
+/// The remote source node RPC URL for the Docker Compose environment.
+const RN_REMOTE_SOURCE_RPC_URL: &str = "http://localhost:8546";
+
+/// The l2geth skip signer check node RPC URL for the Docker Compose environment.
+const L2GETH_SKIPSIGNERCHECK_RPC_URL: &str = "http://localhost:8547";
+
+const RN_SEQUENCER_ENODE: &str = "enode://e7f7e271f62bd2b697add14e6987419758c97e83b0478bd948f5f2d271495728e7edef5bd78ad65258ac910f28e86928ead0c42ee51f2a0168d8ca23ba939766@{IP}:30303";
+const RN_REMOTE_SOURCE_ENODE: &str = "enode://849431bd98c23f8203cf475cfd8efb980d1e2af46337141cfb7dd960d4ae6f8c489846da293305705c8918fbf991e41805afc8c7231c96f3f938120b6826affc@{IP}:30303";
 const L2GETH_SEQUENCER_ENODE: &str = "enode://8fc4f6dfd0a2ebf56560d0b0ef5e60ad7bcb01e13f929eae53a4c77086d9c1e74eb8b8c8945035d25c6287afdd871f0d41b3fd7e189697decd0f13538d1ac620@{IP}:30303";
 
 pub struct DockerComposeEnv {
@@ -83,6 +91,33 @@ impl DockerComposeEnv {
         Ok(env)
     }
 
+    /// Create a new DockerComposeEnv for remote block source tests and wait for all services to be
+    /// ready
+    pub async fn new_remote_source(test_name: &str) -> Result<Self> {
+        let project_name = format!("test-{test_name}");
+        let compose_file = "docker-compose.remote-source.yml";
+
+        tracing::info!("🚀 Starting test environment: {project_name}");
+
+        // Pre-cleanup existing containers to avoid conflicts
+        Self::cleanup(compose_file, &project_name, false);
+
+        // Start the environment
+        let env = Self::start_environment(compose_file, &project_name)?;
+
+        // Start streaming logs in the background
+        let _ = Self::stream_container_logs(compose_file, &project_name).await;
+
+        // Wait for all services to be ready
+        tracing::info!("⏳ Waiting for services to be ready...");
+        Self::wait_for_l2_node_ready(RN_SEQUENCER_RPC_URL, 30).await?;
+        Self::wait_for_l2_node_ready(RN_REMOTE_SOURCE_RPC_URL, 30).await?;
+        Self::wait_for_l2_node_ready(L2GETH_SKIPSIGNERCHECK_RPC_URL, 30).await?;
+
+        tracing::info!("✅ All services are ready!");
+        Ok(env)
+    }
+
     fn start_environment(compose_file: &str, project_name: &str) -> Result<Self> {
         tracing::info!("📦 Starting docker-compose services...");
 
@@ -188,6 +223,21 @@ impl DockerComposeEnv {
         ))
     }
 
+    /// Get a configured remote source provider
+    pub async fn get_rn_remote_source_provider(&self) -> Result<NamedProvider> {
+        let provider = ProviderBuilder::<_, _, Scroll>::default()
+            .with_recommended_fillers()
+            .connect(RN_REMOTE_SOURCE_RPC_URL)
+            .await
+            .map_err(|e| eyre::eyre!("Failed to connect to RN remote source: {}", e))?;
+        Ok(NamedProvider::new(
+            Box::new(provider),
+            "RN Remote Source",
+            "rollup-node-remote-source",
+            RN_REMOTE_SOURCE_RPC_URL,
+        ))
+    }
+
     /// Get a configured l2geth sequencer provider
     pub async fn get_l2geth_sequencer_provider(&self) -> Result<NamedProvider> {
         let provider = ProviderBuilder::<_, _, Scroll>::default()
@@ -218,6 +268,21 @@ impl DockerComposeEnv {
         ))
     }
 
+    /// Get a configured l2geth skip signer check provider
+    pub async fn get_l2geth_skipsignercheck_provider(&self) -> Result<NamedProvider> {
+        let provider = ProviderBuilder::<_, _, Scroll>::default()
+            .with_recommended_fillers()
+            .connect(L2GETH_SKIPSIGNERCHECK_RPC_URL)
+            .await
+            .map_err(|e| eyre::eyre!("Failed to connect to l2geth skip signer check: {}", e))?;
+        Ok(NamedProvider::new(
+            Box::new(provider),
+            "L2Geth SkipSignerCheck",
+            "l2geth-skipsignercheck",
+            L2GETH_SKIPSIGNERCHECK_RPC_URL,
+        ))
+    }
+
     // ===== UTILITIES =====
 
     /// Wait for L2 node to be ready
@@ -441,6 +506,13 @@ impl DockerComposeEnv {
         Ok(RN_SEQUENCER_ENODE.replace("{IP}", &ip))
     }
 
+    /// Get the rollup node remote source enode URL with resolved IP address
+    pub fn rn_remote_source_enode(&self) -> Result<String> {
+        let ip =
+            self.get_container_ip(&self.get_full_container_name("rollup-node-remote-source"))?;
+        Ok(RN_REMOTE_SOURCE_ENODE.replace("{IP}", &ip))
+    }
+
     /// Get the l2geth sequencer enode URL with resolved IP address
     pub fn l2geth_sequencer_enode(&self) -> Result<String> {
         let ip = self.get_container_ip(&self.get_full_container_name("l2geth-sequencer"))?;

tests/tests/remote_block_source_docker.rs

@@ -0,0 +1,67 @@
+use eyre::Result;
+use tests::*;
+
+#[tokio::test]
+async fn docker_test_remote_block_source_basic() -> Result<()> {
+    reth_tracing::init_test_tracing();
+
+    tracing::info!("=== STARTING docker_test_remote_block_source_basic ===");
+    let env = DockerComposeEnv::new_remote_source("docker_test_remote_block_source_basic").await?;
+
+    let rn_sequencer = env.get_rn_sequencer_provider().await?;
+    let rn_remote_source = env.get_rn_remote_source_provider().await?;
+    let l2geth = env.get_l2geth_skipsignercheck_provider().await?;
+
+    utils::enable_automatic_sequencing(&rn_sequencer).await?;
+
+    let target_block = 10;
+    utils::wait_for_block(&[&rn_sequencer], target_block).await?;
+    let sequencer_block = rn_sequencer.get_block_number().await?;
+
+    utils::wait_for_block(&[&rn_remote_source], sequencer_block).await?;
+    utils::assert_blocks_match(&[&rn_sequencer, &rn_remote_source], sequencer_block).await?;
+
+    utils::admin_add_peer(&l2geth, &env.rn_remote_source_enode()?).await?;
+    utils::wait_for_block(&[&l2geth], sequencer_block).await?;
+    utils::assert_blocks_match(&[&rn_remote_source, &l2geth], sequencer_block).await?;
+
+    let remote_block = rn_remote_source.get_block_number().await?;
+    assert!(
+        remote_block >= sequencer_block,
+        "remote source should be at or ahead of sequencer: remote={}, sequencer={}",
+        remote_block,
+        sequencer_block
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn docker_test_remote_block_source_recovery() -> Result<()> {
+    reth_tracing::init_test_tracing();
+
+    tracing::info!("=== STARTING docker_test_remote_block_source_recovery ===");
+    let env = DockerComposeEnv::new_remote_source("docker_test_remote_block_source_recovery").await?;
+
+    let rn_sequencer = env.get_rn_sequencer_provider().await?;
+    let rn_remote_source = env.get_rn_remote_source_provider().await?;
+
+    utils::enable_automatic_sequencing(&rn_sequencer).await?;
+
+    let target_block = 10;
+    utils::wait_for_block(&[&rn_sequencer], target_block).await?;
+    let sequencer_block = rn_sequencer.get_block_number().await?;
+    utils::wait_for_block(&[&rn_remote_source], sequencer_block).await?;
+
+    tracing::info!("Restarting rollup-node-sequencer container");
+    env.restart_container(&rn_sequencer).await?;
+    let rn_sequencer = env.get_rn_sequencer_provider().await?;
+    utils::enable_automatic_sequencing(&rn_sequencer).await?;
+
+    let target_block = sequencer_block + 5;
+    utils::wait_for_block(&[&rn_sequencer], target_block).await?;
+    utils::wait_for_block(&[&rn_remote_source], target_block).await?;
+    utils::assert_blocks_match(&[&rn_sequencer, &rn_remote_source], target_block).await?;
+
+    Ok(())
+}