Add op-alloy-flz dependency and update related configurations

- Added `op-alloy-flz` as a dependency in `Cargo.toml` and `Cargo.lock`.
- Configured `op-alloy-flz` to be part of the workspace in `op-rbuilder`'s `Cargo.toml`.
- Updated the `payload_builder_vanilla.rs` to utilize `op-alloy-flz` for transaction size estimation.
- Enhanced test framework to include new data availability tests ensuring block size limits are respected.

Author: SozinM

Cargo.lock

@@ -131,6 +131,7 @@ op-alloy-rpc-types-engine = { version = "0.16.0", default-features = false }
 op-alloy-rpc-jsonrpsee = { version = "0.16.0", default-features = false }
 op-alloy-network = { version = "0.16.0", default-features = false }
 op-alloy-consensus = { version = "0.16.0", default-features = false }
+op-alloy-flz = { version = "0.13.0", default-features = false }
 
 async-trait = { version = "0.1.83" }
 clap = { version = "4.4.3", features = ["derive", "env"] }

Cargo.toml

@@ -62,6 +62,7 @@ alloy-op-evm.workspace = true
 op-alloy-consensus.workspace = true
 op-alloy-rpc-types-engine.workspace = true
 op-alloy-network.workspace = true
+op-alloy-flz.workspace = true
 
 revm.workspace = true
 op-revm.workspace = true

crates/op-rbuilder/Cargo.toml

@@ -8,9 +8,9 @@ use alloy_consensus::{
     constants::EMPTY_WITHDRAWALS, transaction::Recovered, Eip658Value, Header, Transaction,
     TxEip1559, Typed2718, EMPTY_OMMER_ROOT_HASH,
 };
-use alloy_eips::{eip7685::EMPTY_REQUESTS_HASH, merge::BEACON_NONCE};
+use alloy_eips::{eip7685::EMPTY_REQUESTS_HASH, merge::BEACON_NONCE, Encodable2718};
 use alloy_op_evm::block::receipt_builder::OpReceiptBuilder;
-use alloy_primitives::{private::alloy_rlp::Encodable, Address, Bytes, TxHash, TxKind, U256};
+use alloy_primitives::{Address, Bytes, TxHash, TxKind, U256};
 use alloy_rpc_types_engine::PayloadId;
 use alloy_rpc_types_eth::Withdrawals;
 use op_alloy_consensus::{OpDepositReceipt, OpTypedTransaction};
@@ -582,15 +582,7 @@ impl<Txs> OpBuilder<'_, Txs> {
         let block_da_limit = ctx
             .da_config
             .max_da_block_size()
-            .map(|da_size| da_size - builder_tx_da_size as u64);
-        // Check that it's possible to create builder tx, considering max_da_tx_size, otherwise panic
-        if let Some(tx_da_limit) = ctx.da_config.max_da_tx_size() {
-            // Panic indicate max_da_tx_size misconfiguration
-            assert!(
-                tx_da_limit >= builder_tx_da_size as u64,
-                "The configured da_config.max_da_tx_size is too small to accommodate builder tx."
-            );
-        }
+            .map(|da_size| da_size.saturating_sub(builder_tx_da_size));
 
         if !ctx.attributes().no_tx_pool {
             let best_txs_start_time = Instant::now();
@@ -1314,7 +1306,7 @@ where
         db: &mut State<DB>,
         builder_tx_gas: u64,
         message: Vec<u8>,
-    ) -> Option<usize>
+    ) -> Option<u64>
     where
         DB: Database<Error = ProviderError>,
     {
@@ -1325,7 +1317,9 @@ where
                 // Create and sign the transaction
                 let builder_tx =
                     signed_builder_tx(db, builder_tx_gas, message, signer, base_fee, chain_id)?;
-                Ok(builder_tx.length())
+                Ok(op_alloy_flz::tx_estimated_size_fjord(
+                    builder_tx.encoded_2718().as_slice(),
+                ))
             })
             .transpose()
             .unwrap_or_else(|err: PayloadBuilderError| {

crates/op-rbuilder/src/payload_builder_vanilla.rs

@@ -66,7 +66,7 @@ impl TestHarnessBuilder {
         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
@@ -93,8 +93,9 @@ impl TestHarnessBuilder {
             .network_port(get_available_port())
             .http_port(builder_http_port)
             .with_builder_private_key(BUILDER_PRIVATE_KEY)
-            .with_revert_protection(self.use_revert_protection);
-
+            .with_revert_protection(self.use_revert_protection)
+            .with_max_da_block_size(self.max_da_block_size)
+            .with_max_da_tx_size(self.max_da_tx_size);
         if let Some(flashblocks_ws_url) = self.flashblocks_ws_url {
             op_rbuilder_config = op_rbuilder_config.with_flashblocks_ws_url(&flashblocks_ws_url);
         }

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

@@ -86,13 +86,13 @@ impl OpRbuilderConfig {
         self
     }
 
-    pub fn with_max_da_tx_size(mut self, size: u64) -> Self {
-        self.max_da_tx_size = Some(size);
+    pub fn with_max_da_tx_size(mut self, size: Option<u64>) -> Self {
+        self.max_da_tx_size = size;
         self
     }
 
-    pub fn with_max_da_block_size(mut self, size: u64) -> Self {
-        self.max_da_block_size = Some(size);
+    pub fn with_max_da_block_size(mut self, size: Option<u64>) -> Self {
+        self.max_da_block_size = size;
         self
     }
 }
@@ -168,12 +168,12 @@ impl Service for OpRbuilderConfig {
         }
 
         if let Some(max_da_tx_size) = self.max_da_tx_size {
-            cmd.arg("--rollup.max-da-tx-size")
+            cmd.arg("--builder.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")
+            cmd.arg("--builder.max-da-block-size")
                 .arg(max_da_block_size.to_string());
         }
 

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

@@ -1,10 +1,10 @@
-use crate::tests::framework::{TestHarnessBuilder};
+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")
+    let harness = TestHarnessBuilder::new("data_availability_tx_size_limit")
         .with_max_da_tx_size(1)
         .build()
         .await?;
@@ -17,7 +17,75 @@ async fn data_availability_tx_size_limit() -> eyre::Result<()> {
     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");
-    
+    assert!(
+        block.not_includes(*invalid_tx.tx_hash()),
+        "transaction should not be included in the block"
+    );
+
+    Ok(())
+}
+
+/// This test ensures that the block 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_block_size_limit() -> eyre::Result<()> {
+    let harness = TestHarnessBuilder::new("data_availability_block_size_limit")
+        .with_max_da_block_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(())
+}
+
+/// This test ensures that block will fill up to the limit.
+/// Size of each transaction is 100000000
+/// We will set limit to 3 txs and see that the builder will include 3 transactions.
+/// We should not forget about builder transaction so we will spawn only 2 regular txs.
+#[tokio::test]
+async fn data_availability_block_fill() -> eyre::Result<()> {
+    let harness = TestHarnessBuilder::new("data_availability_block_fill")
+        .with_max_da_block_size(100000000 * 3)
+        .build()
+        .await?;
+
+    let mut generator = harness.block_generator().await?;
+
+    // generate regualr tx
+    let valid_tx_1 = harness.send_valid_transaction().await?;
+    let valid_tx_2 = harness.send_valid_transaction().await?;
+    let unfit_tx_3 = 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.includes(*valid_tx_1.tx_hash()),
+        "tx should be in block"
+    );
+    assert!(
+        block.includes(*valid_tx_2.tx_hash()),
+        "tx should be in block"
+    );
+    assert!(
+        block.not_includes(*unfit_tx_3.tx_hash()),
+        "unfit tx should not be in block"
+    );
+    assert!(
+        harness.latest_block().await.transactions.len() == 4,
+        "builder + deposit + 2 valid txs should be in the block"
+    );
     Ok(())
 }

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

@@ -1,8 +1,8 @@
 #![cfg(test)]
 
+mod data_availability;
 mod ordering;
 mod revert;
 mod smoke;
-mod data_availability;
 
 use super::*;