Add max data availability transaction and block size configuration

- Introduced `max_da_tx_size` and `max_da_block_size` fields in `TestHarnessBuilder` and `OpRbuilderConfig`.
- Added builder methods `with_max_da_tx_size` and `with_max_da_block_size` for setting these values.
- Implemented a new test to ensure transaction size limits are respected in data availability scenarios.
- Updated test module to include the new data availability test.

Author: SozinM

crates/op-rbuilder/src/tests/framework/harness.rs

@@ -25,6 +25,8 @@ pub struct TestHarnessBuilder {
     flashblocks_ws_url: Option<String>,
     chain_block_time: Option<u64>,
     flashbots_block_time: Option<u64>,
+    max_da_tx_size: Option<u64>,
+    max_da_block_size: Option<u64>,
 }
 
 impl TestHarnessBuilder {
@@ -35,6 +37,8 @@ impl TestHarnessBuilder {
             flashblocks_ws_url: None,
             chain_block_time: None,
             flashbots_block_time: None,
+            max_da_tx_size: None,
+            max_da_block_size: None,
         }
     }
 
@@ -58,6 +62,16 @@ impl TestHarnessBuilder {
         self
     }
 
+    pub fn with_max_da_tx_size(mut self, max_da_tx_size: u64) -> Self {
+        self.max_da_tx_size = Some(max_da_tx_size);
+        self
+    }
+    
+    pub fn with_max_da_block_size(mut self, max_da_block_size: u64) -> Self {
+        self.max_da_block_size = Some(max_da_block_size);
+        self
+    }
+
     pub async fn build(self) -> eyre::Result<TestHarness> {
         let mut framework = IntegrationFramework::new(&self.name).unwrap();
 

crates/op-rbuilder/src/tests/framework/op.rs

@@ -27,6 +27,8 @@ pub struct OpRbuilderConfig {
     chain_block_time: Option<u64>,
     flashbots_block_time: Option<u64>,
     with_revert_protection: Option<bool>,
+    max_da_tx_size: Option<u64>,
+    max_da_block_size: Option<u64>,
 }
 
 impl OpRbuilderConfig {
@@ -83,6 +85,16 @@ impl OpRbuilderConfig {
         self.flashbots_block_time = Some(time);
         self
     }
+
+    pub fn with_max_da_tx_size(mut self, size: u64) -> Self {
+        self.max_da_tx_size = Some(size);
+        self
+    }
+
+    pub fn with_max_da_block_size(mut self, size: u64) -> Self {
+        self.max_da_block_size = Some(size);
+        self
+    }
 }
 
 impl Service for OpRbuilderConfig {
@@ -155,6 +167,16 @@ impl Service for OpRbuilderConfig {
                 .arg(flashbots_block_time.to_string());
         }
 
+        if let Some(max_da_tx_size) = self.max_da_tx_size {
+            cmd.arg("--rollup.max-da-tx-size")
+                .arg(max_da_tx_size.to_string());
+        }
+
+        if let Some(max_da_block_size) = self.max_da_block_size {
+            cmd.arg("--rollup.max-da-block-size")
+                .arg(max_da_block_size.to_string());
+        }
+
         cmd
     }
 

crates/op-rbuilder/src/tests/vanilla/data_availability.rs

@@ -0,0 +1,23 @@
+use crate::tests::framework::{TestHarnessBuilder};
+
+/// This test ensures that the transaction size limit is respected.
+/// We will set limit to 1 byte and see that the builder will not include any transactions.
+#[tokio::test]
+async fn data_availability_tx_size_limit() -> eyre::Result<()> {
+    let harness = TestHarnessBuilder::new("integration_test_data_availability")
+        .with_max_da_tx_size(1)
+        .build()
+        .await?;
+
+    let mut generator = harness.block_generator().await?;
+
+    // generate regualr tx
+    let invalid_tx = harness.send_valid_transaction().await?;
+
+    let block = generator.generate_block().await?;
+
+    // tx should not be included because we set the tx_size_limit to 1
+    assert!(block.not_includes(*invalid_tx.tx_hash()), "transaction should not be included in the block");
+    
+    Ok(())
+}

crates/op-rbuilder/src/tests/vanilla/mod.rs

@@ -3,5 +3,6 @@
 mod ordering;
 mod revert;
 mod smoke;
+mod data_availability;
 
 use super::*;