fix all the tests

Author: akundaz

src/limits.rs

@@ -12,6 +12,7 @@ use {
 	core::time::Duration,
 	rblib::{alloy::consensus::BlockHeader, prelude::*},
 	std::sync::{Arc, Mutex},
+	tracing::debug,
 };
 
 /// Specifies the limits for individual flashblocks.
@@ -54,8 +55,12 @@ impl FlashblockState {
 }
 
 impl FlashblockLimits {
-	pub fn new(interval: Duration) -> Self {
+	pub fn new(
+		interval: Duration,
+		target_flashblocks: Arc<TargetFlashblocks>,
+	) -> Self {
 		let state = FlashblockState {
+			target_flashblocks,
 			..Default::default()
 		};
 		FlashblockLimits {
@@ -87,16 +92,22 @@ impl FlashblockLimits {
 			let elapsed = payload.building_since().elapsed();
 			let remaining_time = payload_deadline.saturating_sub(elapsed);
 
-			let (target_flashblock, first_flashblock_interval) =
+			let (target_flashblocks, first_flashblock_interval) =
 				self.calculate_flashblocks(payload, remaining_time);
 
 			state.gas_per_flashblock = enclosing
 				.gas_limit
-				.checked_div(target_flashblock)
+				.checked_div(target_flashblocks)
 				.unwrap_or(enclosing.gas_limit);
 			state.current_block = Some(payload.block().number());
 			state.first_flashblock_interval = first_flashblock_interval;
-			state.target_flashblocks.set(target_flashblock);
+			state.target_flashblocks.set(target_flashblocks);
+
+			debug!(
+				target_flashblocks = target_flashblocks,
+				first_flashblock_interval = ?first_flashblock_interval,
+				"Set flashblock timing for this block"
+			);
 		}
 	}
 

src/main.rs

@@ -20,6 +20,7 @@ use {
 		steps::*,
 	},
 	std::sync::Arc,
+	tracing::info,
 };
 
 mod args;
@@ -106,6 +107,11 @@ fn build_pipeline(
 
 	let target_flashblocks = Arc::new(TargetFlashblocks::new());
 
+	info!(
+		"cli_args.builder_signer.is_some() = {}",
+		cli_args.builder_signer.is_some()
+	);
+
 	let pipeline = Pipeline::<Flashblocks>::named("top")
 		.with_step(OptimismPrologue)
 		.with_step_if(
@@ -123,27 +129,34 @@ fn build_pipeline(
 					Once,
 					Pipeline::named("single_flashblock")
 						.with_pipeline(
-							Loop,
+							Once,
 							Pipeline::named("flashblock_steps")
-								.with_step(AppendOrders::from_pool(pool).with_ok_on_limit())
-								.with_step(OrderByPriorityFee::default())
-								.with_step_if(
-									cli_args.revert_protection,
-									RemoveRevertedTransactions::default(),
+								.with_pipeline(
+									Loop,
+									Pipeline::named("inner_flashblock_steps")
+										.with_step(AppendOrders::from_pool(pool).with_ok_on_limit())
+										.with_step(OrderByPriorityFee::default())
+										.with_step_if(
+											cli_args.revert_protection,
+											RemoveRevertedTransactions::default(),
+										)
+										.with_step(BreakAfterDeadline),
 								)
-								.with_step(BreakAfterDeadline)
-								.with_epilogue_if(
+								.with_step_if(
 									cli_args.builder_signer.is_some(),
 									BuilderEpilogue::with_signer(builder_signer.clone().into())
 										.with_message(|block| {
 											format!("Block Number: {}", block.number())
 										}),
 								)
-								.with_epilogue(PublishFlashblock::new(
+								.with_step(PublishFlashblock::new(
 									ws.clone(),
 									cli_args.flashblocks_args.calculate_state_root,
 								))
-								.with_limits(FlashblockLimits::new(interval)),
+								.with_limits(FlashblockLimits::new(
+									interval,
+									target_flashblocks.clone(),
+								)),
 						)
 						.with_step(BreakAfterDeadline),
 				)

src/publish.rs

@@ -89,6 +89,7 @@ impl Step<Flashblocks> for PublishFlashblock {
 			.transactions()
 			.map(|tx| tx.encoded_2718().into())
 			.collect();
+		let num_txs = transactions.len();
 
 		let sealed_block = payload.build_payload();
 		if let Err(e) = sealed_block {
@@ -136,10 +137,11 @@ impl Step<Flashblocks> for PublishFlashblock {
 		}
 
 		info!(
-			"Published flashblock {}, num_transactions: {}, gas_used: {}",
-			index,
-			payload.history().transactions().count(),
-			payload.gas_used()
+			index = index,
+			num_transactions = num_txs,
+			cumulative_gas_used = payload.gas_used(),
+			payload_id = ?ctx.block().payload_id(),
+			"Published flashblock",
 		);
 
 		// block published to WS successfully
@@ -214,21 +216,14 @@ impl Step<Flashblocks> for PublishFlashblock {
 }
 
 impl PublishFlashblock {
-	/// Returns a span that covers all payload checkpoints since the last barrier.
-	/// Those are the transactions that are going to be published in this
+	/// Returns a span that covers all payload checkpoints for the current
 	/// flashblock.
-	///
-	/// One exception is the first flashblock, we want to get all checkpoints
-	/// since the begining of the block, because the `OptimismPrologue` step
-	/// places a barrier after sequencer transactions and we want to broadcast
-	/// those transactions as well.
 	fn unpublished_payload(
 		payload: &Checkpoint<Flashblocks>,
 	) -> Span<Flashblocks> {
-		// If we haven't published flashblock return whole history
-		let previous_flashblock_number = payload.context().clone();
+		let current_flashblock_number = payload.context();
 		payload
-			.history_since_last_context(&previous_flashblock_number)
+			.history_since_first_context(current_flashblock_number)
 			.unwrap_or(payload.history())
 	}
 

src/tests/flashblocks.rs

@@ -26,7 +26,11 @@ async fn empty_blocks_smoke() -> eyre::Result<()> {
 			// The first flashblock will have the sequencer tx and the rest
 			// should be empty
 			let expected_tx_count = usize::from(j == 0);
-			assert_eq!(expected_tx_count, flashblock.diff.transactions.len());
+			assert_eq!(
+				expected_tx_count,
+				flashblock.diff.transactions.len(),
+				"expected {expected_tx_count} transactions in flashblock {j}",
+			);
 		}
 	}
 

src/tests/standard.rs

@@ -69,7 +69,6 @@ async fn blocks_have_builder_tx() -> eyre::Result<()> {
 		Box::pin(Flashblocks::test_node_with_builder_signer()).await?;
 
 	let block = node.next_block().await?;
-	debug!("produced block: {block:#?}");
 
 	assert_eq!(block.number(), 1);
 	assert_eq!(block.tx_count(), 9); // sequencer deposit tx + 8 builder txs for each flashblock

src/tests/utils/ws.rs

@@ -164,7 +164,12 @@ impl Observations {
 	}
 
 	fn record_flashblock(&self, payload: FlashblocksPayloadV1) {
-		debug!("observed flashblock: {payload:#?}");
+		debug!(
+			index = payload.index,
+			payload_id = ?payload.payload_id,
+			num_transactions = payload.diff.transactions.len(),
+			"Observed flashblock"
+		);
 		self.flashblocks.push(ObservedFlashblock {
 			block: payload,
 			at: Instant::now(),