remove SealedCtx in favor of SlotMeta+Payload per hook derivation

Author: julio4

crates/op-rbuilder/src/builder/hooks/channel.rs

@@ -1,32 +1,29 @@
-use crate::builder::hooks::post_seal::{PostSealHook, SealedCandidate, SealedCtx};
+use crate::builder::hooks::post_seal::{PostSealHook, SealedCandidate, SlotMeta};
 use reth_optimism_node::OpBuiltPayload;
 use tokio::sync::mpsc;
 use tracing::warn;
 
 /// Forwards each sealed candidate over a named mpsc channel.
 #[derive(Debug)]
-pub(in crate::builder) struct ChannelHook {
+pub(crate) struct ChannelHook {
     name: &'static str,
     sender: mpsc::Sender<OpBuiltPayload>,
 }
 
 impl ChannelHook {
-    pub(in crate::builder) fn new(
-        name: &'static str,
-        sender: mpsc::Sender<OpBuiltPayload>,
-    ) -> Self {
+    pub(crate) fn new(name: &'static str, sender: mpsc::Sender<OpBuiltPayload>) -> Self {
         Self { name, sender }
     }
 }
 
 impl PostSealHook for ChannelHook {
-    fn on_sealed(&self, candidate: &SealedCandidate, ctx: &SealedCtx) {
+    fn on_sealed(&self, candidate: &SealedCandidate, _slot: &SlotMeta) {
         if let Err(e) = self.sender.try_send(candidate.payload.clone()) {
             warn!(
                 target: "payload_builder",
                 channel = self.name,
                 error = %e,
-                flashblock_index = ctx.flashblock_index,
+                flashblock_index = candidate.fb_payload.index,
                 "Failed to forward sealed payload over channel"
             );
         }

crates/op-rbuilder/src/builder/hooks/metrics.rs

@@ -1,29 +1,29 @@
 use crate::{
-    builder::hooks::post_seal::{PostSealHook, SealedCandidate, SealedCtx},
+    builder::hooks::post_seal::{PostSealHook, SealedCandidate, SlotMeta},
     metrics::OpRBuilderMetrics,
 };
 use std::sync::Arc;
 
 /// Records per-flashblock metrics that aren't tied to publication:
 /// build duration and transaction-count histogram.
 #[derive(Debug)]
-pub(in crate::builder) struct MetricsHook {
+pub(crate) struct MetricsHook {
     metrics: Arc<OpRBuilderMetrics>,
 }
 
 impl MetricsHook {
-    pub(in crate::builder) fn new(metrics: Arc<OpRBuilderMetrics>) -> Self {
+    pub(crate) fn new(metrics: Arc<OpRBuilderMetrics>) -> Self {
         Self { metrics }
     }
 }
 
 impl PostSealHook for MetricsHook {
-    fn on_sealed(&self, _candidate: &SealedCandidate, ctx: &SealedCtx) {
-        if let Some(duration) = ctx.flashblock_build_duration {
+    fn on_sealed(&self, candidate: &SealedCandidate, _slot: &SlotMeta) {
+        if let Some(duration) = candidate.build_duration {
             self.metrics.flashblock_build_duration.record(duration);
         }
         self.metrics
             .flashblock_num_tx_histogram
-            .record(ctx.executed_tx_count as f64);
+            .record(candidate.payload.block().body().transactions.len() as f64);
     }
 }

crates/op-rbuilder/src/builder/hooks/mod.rs

@@ -12,7 +12,7 @@ mod ws;
 
 pub(super) use channel::ChannelHook;
 pub(super) use metrics::MetricsHook;
-pub(super) use post_seal::{PostSealHook, SealedCandidate, SealedCtx};
+pub(super) use post_seal::{PostSealHook, SealedCandidate, SlotMeta};
 pub(super) use ws::WsHook;
 
 /// Dispatch a sealed candidate to every hook in `hooks`.
@@ -22,9 +22,9 @@ pub(super) use ws::WsHook;
 pub(super) fn dispatch_post_seal(
     hooks: &[Box<dyn PostSealHook>],
     candidate: &SealedCandidate,
-    ctx: &SealedCtx,
+    slot: &SlotMeta,
 ) {
     for h in hooks {
-        h.on_sealed(candidate, ctx);
+        h.on_sealed(candidate, slot);
     }
 }

crates/op-rbuilder/src/builder/hooks/post_seal.rs

@@ -8,39 +8,31 @@ use reth_payload_builder::PayloadId;
 ///
 /// `payload` is the full built payload for engine/p2p delivery; `fb_payload`
 /// is the slim, serialisable view streamed to flashblocks subscribers.
+/// `build_duration` is the wall-clock time spent building this flashblock,
+/// or `None` for the fallback candidate (no incremental build step).
 #[derive(Debug, Clone)]
-pub(in crate::builder) struct SealedCandidate {
+pub(crate) struct SealedCandidate {
     pub payload: OpBuiltPayload,
     pub fb_payload: OpFlashblockPayload,
+    pub build_duration: Option<Duration>,
 }
 
-/// Context describing the slot a sealed candidate belongs to.
-///
-/// The fields are intentionally limited to data downstream hooks need.
+/// Slot-level metadata for a given building slot.
 #[derive(Debug, Clone)]
-pub(in crate::builder) struct SealedCtx {
+pub(crate) struct SlotMeta {
     pub payload_id: PayloadId,
-    pub block_number: u64,
-    pub flashblock_index: u64,
     /// True when the FCU specified `no_tx_pool`.
     pub no_tx_pool: bool,
-    pub executed_tx_count: usize,
     /// Slot start timestamp from the payload attributes.
     pub slot_timestamp_secs: u64,
     pub block_time: Duration,
-    /// Wall-clock time spent building this flashblock.
-    /// `None` for the fallback candidate.
-    pub flashblock_build_duration: Option<Duration>,
-    pub enable_tx_tracking_debug_logs: bool,
 }
 
 /// Hook invoked after a flashblock or fallback candidate has been sealed.
 ///
 /// Implementations should be cheap and non-blocking: dispatch happens on the
 /// builder's hot path. Errors are intentionally swallowed at the dispatch site;
 /// hooks that want to surface failures should do so via metrics or logs.
-pub(in crate::builder) trait PostSealHook:
-    Send + Sync + std::fmt::Debug
-{
-    fn on_sealed(&self, candidate: &SealedCandidate, ctx: &SealedCtx);
+pub(crate) trait PostSealHook: Send + Sync + std::fmt::Debug {
+    fn on_sealed(&self, candidate: &SealedCandidate, slot: &SlotMeta);
 }

crates/op-rbuilder/src/builder/hooks/ws.rs

@@ -1,6 +1,6 @@
 use crate::{
     builder::{
-        hooks::post_seal::{PostSealHook, SealedCandidate, SealedCtx},
+        hooks::post_seal::{PostSealHook, SealedCandidate, SlotMeta},
         timing::compute_slot_offset_ms,
         wspub::WebSocketPublisher,
     },
@@ -11,10 +11,11 @@ use tracing::{debug, warn};
 
 /// Publishes the flashblock payload to WebSocket subscribers, record metrics.
 ///
-/// Suppressed when `SealedCtx::no_tx_pool` is true
-pub(in crate::builder) struct WsHook {
+/// Suppressed when `SlotMeta::no_tx_pool` is true.
+pub(crate) struct WsHook {
     ws_pub: Arc<WebSocketPublisher>,
     metrics: Arc<OpRBuilderMetrics>,
+    enable_tx_tracking_debug_logs: bool,
 }
 
 impl std::fmt::Debug for WsHook {
@@ -24,17 +25,22 @@ impl std::fmt::Debug for WsHook {
 }
 
 impl WsHook {
-    pub(in crate::builder) fn new(
+    pub(crate) fn new(
         ws_pub: Arc<WebSocketPublisher>,
         metrics: Arc<OpRBuilderMetrics>,
+        enable_tx_tracking_debug_logs: bool,
     ) -> Self {
-        Self { ws_pub, metrics }
+        Self {
+            ws_pub,
+            metrics,
+            enable_tx_tracking_debug_logs,
+        }
     }
 }
 
 impl PostSealHook for WsHook {
-    fn on_sealed(&self, candidate: &SealedCandidate, ctx: &SealedCtx) {
-        if ctx.no_tx_pool {
+    fn on_sealed(&self, candidate: &SealedCandidate, slot: &SlotMeta) {
+        if slot.no_tx_pool {
             return;
         }
 
@@ -44,27 +50,27 @@ impl PostSealHook for WsHook {
                 warn!(
                     target: "payload_builder",
                     error = %e,
-                    flashblock_index = ctx.flashblock_index,
+                    flashblock_index = candidate.fb_payload.index,
                     "Failed to publish flashblock via websocket"
                 );
                 return;
             }
         };
 
-        let slot_offset_ms = compute_slot_offset_ms(ctx.slot_timestamp_secs, ctx.block_time);
+        let slot_offset_ms = compute_slot_offset_ms(slot.slot_timestamp_secs, slot.block_time);
         record_flashblock_publish_timing(candidate.fb_payload.index, slot_offset_ms);
         self.metrics
             .flashblock_byte_size_histogram
             .record(byte_size as f64);
 
-        if ctx.enable_tx_tracking_debug_logs {
+        if self.enable_tx_tracking_debug_logs {
             debug!(
                 target: "tx_trace",
-                payload_id = %ctx.payload_id,
-                block_number = ctx.block_number,
+                payload_id = %slot.payload_id,
+                block_number = candidate.payload.block().header().number,
                 flashblock_index = candidate.fb_payload.index,
                 byte_size,
-                total_txs = ctx.executed_tx_count,
+                total_txs = candidate.payload.block().body().transactions.len(),
                 slot_offset_ms,
                 stage = "fb_published"
             );

crates/op-rbuilder/src/builder/payload.rs

@@ -8,7 +8,7 @@ use crate::{
         context::{OpPayloadBuilderCtx, OpPayloadJobCtx},
         generator::{BuildArguments, PayloadBuilder},
         hooks::{
-            ChannelHook, MetricsHook, PostSealHook, SealedCandidate, SealedCtx, WsHook,
+            ChannelHook, MetricsHook, PostSealHook, SealedCandidate, SlotMeta, WsHook,
             dispatch_post_seal,
         },
         timing::FlashblockScheduler,
@@ -113,7 +113,6 @@ struct FlashblockBuildResult {
     new_payload: OpBuiltPayload,
     fb_payload: OpFlashblockPayload,
     build_duration: core::time::Duration,
-    executed_tx_count: usize,
 }
 
 impl FlashblocksState {
@@ -329,7 +328,11 @@ where
 
         let ws_pub = Arc::new(ws_pub);
         let post_seal_hooks: Vec<Box<dyn PostSealHook>> = vec![
-            Box::new(WsHook::new(Arc::clone(&ws_pub), Arc::clone(&metrics))),
+            Box::new(WsHook::new(
+                Arc::clone(&ws_pub),
+                Arc::clone(&metrics),
+                config.enable_tx_tracking_debug_logs,
+            )),
             Box::new(ChannelHook::new("p2p", built_fb_payload_tx)),
             Box::new(ChannelHook::new("engine", built_payload_tx)),
             Box::new(MetricsHook::new(Arc::clone(&metrics))),
@@ -505,19 +508,15 @@ where
         let candidate = SealedCandidate {
             payload: payload.clone(),
             fb_payload: fb_payload.clone(),
+            build_duration: None,
         };
-        let sealed_ctx = SealedCtx {
+        let slot = SlotMeta {
             payload_id: ctx.payload_id(),
-            block_number: ctx.block_number(),
-            flashblock_index: fb_payload.index,
             no_tx_pool: ctx.attributes().no_tx_pool,
-            executed_tx_count: info.executed_transactions.len(),
             slot_timestamp_secs: config.attributes.timestamp(),
             block_time: self.config.block_time,
-            flashblock_build_duration: None,
-            enable_tx_tracking_debug_logs: self.config.enable_tx_tracking_debug_logs,
         };
-        dispatch_post_seal(&self.post_seal_hooks, &candidate, &sealed_ctx);
+        dispatch_post_seal(&self.post_seal_hooks, &candidate, &slot);
         best_payload_tx.send_replace(Some(payload));
 
         info!(
@@ -794,25 +793,20 @@ where
                         new_payload,
                         fb_payload: built_fb_payload,
                         build_duration,
-                        executed_tx_count,
                     } = result;
 
                     let candidate = SealedCandidate {
                         payload: new_payload.clone(),
                         fb_payload: built_fb_payload,
+                        build_duration: Some(build_duration),
                     };
-                    let sealed_ctx = SealedCtx {
+                    let slot = SlotMeta {
                         payload_id: ctx.payload_id(),
-                        block_number: ctx.block_number(),
-                        flashblock_index: candidate.fb_payload.index,
                         no_tx_pool: ctx.attributes().no_tx_pool,
-                        executed_tx_count,
                         slot_timestamp_secs: ctx.attributes().timestamp(),
                         block_time: self.config.block_time,
-                        flashblock_build_duration: Some(build_duration),
-                        enable_tx_tracking_debug_logs: self.config.enable_tx_tracking_debug_logs,
                     };
-                    dispatch_post_seal(&self.post_seal_hooks, &candidate, &sealed_ctx);
+                    dispatch_post_seal(&self.post_seal_hooks, &candidate, &slot);
                     best_payload_tx.send_replace(Some(new_payload));
                     next_fb_state
                 }
@@ -1086,7 +1080,6 @@ where
                     new_payload,
                     fb_payload,
                     build_duration: flashblock_build_start_time.elapsed(),
-                    executed_tx_count: info.executed_transactions.len(),
                 }))
             }
         }