Reproduction Unknown Payload

src/server.rs

@@ -332,6 +332,11 @@ impl EngineApiServer for RollupBoostServer {
         let span = tracing::Span::current();
         if let Some(payload_id) = l2_response.payload_id {
             span.record("payload_id", payload_id.to_string());
+
+            info!(
+                "received fork_choice_updated_v3, payload_id: {}",
+                payload_id
+            );
         }
 
         let (should_send_to_builder, has_attributes, use_tx_pool) =
@@ -394,7 +399,7 @@ impl EngineApiServer for RollupBoostServer {
         &self,
         payload_id: PayloadId,
     ) -> RpcResult<OpExecutionPayloadEnvelopeV3> {
-        info!("received get_payload_v3");
+        info!("received get_payload_v3, payload_id: {}", payload_id);
 
         match self.get_payload(payload_id, Version::V3).await? {
             OpExecutionPayloadEnvelope::V3(v3) => Ok(v3),

tests/builder_full_delay.rs

@@ -1,34 +1,10 @@
 use common::RollupBoostTestHarnessBuilder;
-use common::proxy::ProxyHandler;
-use futures::FutureExt;
-use serde_json::Value;
-use std::pin::Pin;
+use common::proxy_delay::DelayHandler;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 mod common;
 
-// Create a dynamic handler that delays all the calls by 2 seconds
-struct DelayHandler {
-    delay: Arc<Mutex<Duration>>,
-}
-
-impl ProxyHandler for DelayHandler {
-    fn handle(
-        &self,
-        _method: String,
-        _params: Value,
-        _result: Value,
-    ) -> Pin<Box<dyn Future<Output = Option<Value>> + Send>> {
-        let delay = *self.delay.lock().unwrap();
-        async move {
-            tokio::time::sleep(delay).await;
-            None
-        }
-        .boxed()
-    }
-}
-
 #[tokio::test]
 async fn builder_full_delay() -> eyre::Result<()> {
     let delay = Arc::new(Mutex::new(Duration::from_secs(0)));

tests/common/mod.rs

@@ -47,6 +47,7 @@ pub static TEST_DATA: LazyLock<String> =
     LazyLock::new(|| format!("{}/tests/common/test_data", env!("CARGO_MANIFEST_DIR")));
 
 pub mod proxy;
+pub mod proxy_delay;
 pub mod services;
 
 pub struct LoggingConsumer {
@@ -383,6 +384,8 @@ pub struct SimpleBlockGenerator {
     engine_api: EngineApi,
     latest_hash: B256,
     timestamp: u64,
+    version: Version,
+    set_block_time: u64,
     genesis: Genesis,
     current_block_number: u64,
 }
@@ -397,12 +400,19 @@ impl SimpleBlockGenerator {
             validator,
             engine_api,
             latest_hash: B256::ZERO, // temporary value
+            version: Version::V3,
+            set_block_time: 1,
             timestamp: genesis.timestamp,
             genesis,
             current_block_number: 0,
         }
     }
 
+    /// Set the block time for the block generator
+    pub fn set_block_time(&mut self, block_time: u64) {
+        self.set_block_time = block_time;
+    }
+
     /// Initialize the block generator by fetching the latest block
     pub async fn init(&mut self) -> eyre::Result<()> {
         let latest_block = self.engine_api.latest().await?.expect("block not found");
@@ -466,8 +476,8 @@ impl SimpleBlockGenerator {
 
         let payload_id = result.payload_id.expect("missing payload id");
 
-        if !empty_blocks {
-            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        if !empty_blocks && self.set_block_time != 0 {
+            tokio::time::sleep(tokio::time::Duration::from_secs(self.set_block_time)).await;
         }
 
         let payload = self.engine_api.get_payload(version, payload_id).await?;

tests/common/proxy_delay.rs

@@ -0,0 +1,35 @@
+use crate::common::proxy::ProxyHandler;
+use futures::FutureExt;
+use serde_json::Value;
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+// Create a dynamic handler that delays all the calls by 2 seconds
+pub struct DelayHandler {
+    pub delay: Arc<Mutex<Duration>>,
+}
+
+impl DelayHandler {
+    pub fn new(delay: Duration) -> Self {
+        Self {
+            delay: Arc::new(Mutex::new(delay)),
+        }
+    }
+}
+
+impl ProxyHandler for DelayHandler {
+    fn handle(
+        &self,
+        _method: String,
+        _params: Value,
+        _result: Value,
+    ) -> Pin<Box<dyn Future<Output = Option<Value>> + Send>> {
+        let delay = *self.delay.lock().unwrap();
+        async move {
+            tokio::time::sleep(delay).await;
+            None
+        }
+        .boxed()
+    }
+}

tests/fcu_precedes_get_payload.rs

@@ -0,0 +1,36 @@
+mod common;
+
+use common::RollupBoostTestHarnessBuilder;
+use common::proxy_delay::DelayHandler;
+use std::sync::Arc;
+use std::time::Duration;
+
+#[tokio::test]
+async fn fcu_precedes_get_payload() -> eyre::Result<()> {
+    let delay = DelayHandler::new(Duration::from_millis(200));
+
+    let harness = RollupBoostTestHarnessBuilder::new("fcu_precedes_get_payload")
+        .proxy_handler(Arc::new(delay))
+        .build()
+        .await?;
+    let mut block_generator = harness.block_generator().await?;
+    block_generator.set_block_time(0);
+
+    for _ in 0..300 {
+        let (_block, _block_creator) = block_generator.generate_block(false).await?;
+    }
+
+    // Count occurrences of "Unknown payload" in the Rollup-boost logs
+    // TODO: Do not rely on reading logs, maybe use a metric?
+    let content = std::fs::read_to_string(harness.rollup_boost.args().log_file.clone().unwrap())?;
+    let unknown_payload_count = content.matches("Unknown payload").count();
+
+    // TODO: The first iteration of the loop always fails to get the payload.
+    // That is why we are expecting at most one error.
+    assert!(
+        unknown_payload_count <= 1,
+        "Expected at most one 'Unknown payload' error, got {unknown_payload_count}"
+    );
+
+    Ok(())
+}