Scaffold for integration test

Author: ferranbt

src/server.rs

@@ -213,6 +213,12 @@ impl PayloadSource {
     }
 }
 
+#[rpc(client, namespace = "miner")]
+pub trait MinerApi {
+    #[method(name = "setMaxDASize")]
+    async fn set_max_da_size(&self, max_tx_size: u64, max_block_size: u64) -> RpcResult<bool>;
+}
+
 #[rpc(server, client)]
 pub trait EngineApi {
     #[method(name = "engine_forkchoiceUpdatedV3")]

tests/common/mod.rs

@@ -16,8 +16,8 @@ use op_alloy_consensus::TxDeposit;
 use op_alloy_rpc_types_engine::OpPayloadAttributes;
 use parking_lot::Mutex;
 use proxy::{ProxyHandler, start_proxy_server};
-use rollup_boost::DebugClient;
 use rollup_boost::{AuthLayer, AuthService};
+use rollup_boost::{DebugClient, MinerApiClient};
 use rollup_boost::{EngineApiClient, OpExecutionPayloadEnvelope, Version};
 use rollup_boost::{NewPayload, PayloadSource};
 use serde_json::Value;
@@ -150,6 +150,17 @@ impl EngineApi {
         )
         .await?)
     }
+
+    pub async fn set_max_da_size(
+        &self,
+        max_tx_size: u64,
+        max_block_size: u64,
+    ) -> eyre::Result<bool> {
+        Ok(
+            MinerApiClient::set_max_da_size(&self.engine_api_client, max_tx_size, max_block_size)
+                .await?,
+        )
+    }
 }
 
 #[rpc(client, namespace = "eth")]
@@ -372,6 +383,13 @@ impl RollupBoostTestHarness {
         Ok(block_creator)
     }
 
+    pub async fn engine_api(&self) -> eyre::Result<EngineApi> {
+        Ok(EngineApi::new(
+            &self.rollup_boost.rpc_endpoint(),
+            JWT_SECRET,
+        )?)
+    }
+
     pub async fn debug_client(&self) -> DebugClient {
         DebugClient::new(&self.rollup_boost.debug_endpoint()).unwrap()
     }

tests/common/services/op_reth.rs

@@ -136,6 +136,7 @@ impl Image for OpRethImage {
             "--addr=0.0.0.0".to_string(),
             "--http".to_string(),
             "--http.addr=0.0.0.0".to_string(),
+            "--http.api=eth,net,web3,debug,miner".to_string(),
             "--authrpc.port=8551".to_string(),
             "--authrpc.addr=0.0.0.0".to_string(),
             "--authrpc.jwtsecret=/jwt_secret.hex".to_string(),

tests/miner_set_max_da_size.rs

@@ -1,15 +1,60 @@
-use common::RollupBoostTestHarnessBuilder;
+use common::{RollupBoostTestHarnessBuilder, proxy::ProxyHandler};
+use futures::FutureExt as _;
+use serde_json::Value;
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
 
 mod common;
 
+#[derive(Debug, Clone, Default)]
+struct MaxDaSizeHandler {
+    found_max_da_value: Arc<Mutex<u64>>,
+}
+
+impl MaxDaSizeHandler {
+    fn get_found_max_da_value(&self) -> u64 {
+        *self.found_max_da_value.lock().unwrap()
+    }
+}
+
+impl ProxyHandler for MaxDaSizeHandler {
+    fn handle(
+        &self,
+        method: String,
+        params: Value,
+        _result: Value,
+    ) -> Pin<Box<dyn Future<Output = Option<Value>> + Send>> {
+        println!("method: {:?}", method);
+        if method == "miner_setMaxDASize" {
+            // decode the params
+            let params: Vec<u64> = serde_json::from_value(params).unwrap();
+            assert_eq!(params.len(), 2);
+            println!("params: {:?}", params);
+            *self.found_max_da_value.lock().unwrap() = params[0];
+        }
+        async move { None }.boxed()
+    }
+}
+
 #[tokio::test]
 async fn miner_set_max_da_size() -> eyre::Result<()> {
-    let harness = RollupBoostTestHarnessBuilder::new("miner set max da size")
-        .with_isthmus_block(5)
+    let handler = Arc::new(MaxDaSizeHandler::default());
+
+    let harness = RollupBoostTestHarnessBuilder::new("miner_set_max_da_size")
+        .with_isthmus_block(0)
+        .proxy_handler(handler.clone())
         .build()
         .await?;
     let mut block_generator = harness.block_generator().await?;
-    block_generator.generate_builder_blocks(10).await?;
+    block_generator.generate_builder_blocks(1).await?;
+
+    let engine_api = harness.engine_api().await?;
+
+    // send a max da size request
+    let res = engine_api.set_max_da_size(1000000, 1000000).await?;
+    println!("res: {:?}", res);
+    let found = handler.get_found_max_da_value();
+    println!("found: {}", found);
 
     Ok(())
 }