detect used priority update by rejecting reads in reverting call frames

Author: dvush

crates/rbuilder/src/backtest/build_block/full_partial_block_execution_tracer.rs

@@ -237,6 +237,9 @@ impl PartialBlockExecutionTracer for FullPartialBlockExecutionTracer {
                         ExecutionError::PriorityUpdateProducedDelayedRefund => {
                             SimpleOrderExecutionResult::OrderError
                         }
+                        ExecutionError::PriorityUpdatesNotUsed(_) => {
+                            SimpleOrderExecutionResult::OrderError
+                        }
                     };
                     (None, result)
                 }

crates/rbuilder/src/building/mod.rs

@@ -38,10 +38,14 @@ use eth_sparse_mpt::SparseTrieLocalCache;
 use evm::EthCachedEvmFactory;
 use jsonrpsee::core::Serialize;
 use parking_lot::Mutex;
-use priority_update::PriorityUpdatePool;
+use priority_update::{
+    select_unwritten_slots,
+    used_priority_update_tracer::{UsedPriorityStateTracer, UsedStorageSlotStatus},
+    PriorityUpdatePool,
+};
 use rbuilder_primitives::{
-    mev_boost::BidAdjustmentDataV3, BlockSpace, Order, SimValue, SimulatedOrder,
-    TransactionSignedEcRecoveredWithBlobs,
+    evm_inspector::SlotKey, mev_boost::BidAdjustmentDataV3, BlockSpace, Order, SimValue,
+    SimulatedOrder, TransactionSignedEcRecoveredWithBlobs,
 };
 use reth::{
     payload::PayloadId,
@@ -586,6 +590,8 @@ pub enum ExecutionError {
     LowerInsertedValue { before: SimValue, inplace: SimValue },
     #[error("Priority update produced a delayed refund")]
     PriorityUpdateProducedDelayedRefund,
+    #[error("Order did not use the committed priority update slots: {0:?}")]
+    PriorityUpdatesNotUsed(Vec<(SlotKey, UsedStorageSlotStatus)>),
 }
 
 impl ExecutionError {
@@ -749,24 +755,31 @@ impl<Tracer: SimulationTracer, PartialBlockExecutionTracerType: PartialBlockExec
     where
         DB: Database<Error = ProviderError>,
     {
+        let unwritten_priorit_update_slots =
+            select_unwritten_slots(state, &order.used_priority_updates);
         let priority_update_orders =
-            priority_update_pool.get_updates(state, &order.used_priority_updates);
+            priority_update_pool.get_updates(&unwritten_priorit_update_slots);
+
+        let pu_tracer = UsedPriorityStateTracer::new(std::iter::empty());
+        let pu_storage_tracker = pu_tracer.storage_tracker();
 
         let mut fork = PartialBlockFork::new_with_execution_tracer(
             state,
             ctx,
             local_ctx,
             &mut self.partial_block_execution_tracer,
         )
-        .with_tracer(&mut self.tracer);
+        .with_tracer(&mut self.tracer)
+        .with_evm_inspector(pu_tracer.clone());
 
         let rollback = fork.rollback_point();
         let initial_space_state = self.space_state;
 
         let mut priority_updates: Vec<Result<ExecutionResult, ExecutionError>> =
             Vec::with_capacity(priority_update_orders.len());
 
-        for priority_update_order in priority_update_orders {
+        for priority_update_sim in priority_update_orders {
+            let priority_update_order = priority_update_sim.order.as_ref();
             let pu_rollback = fork.rollback_point();
             let exec_result = fork.commit_order(
                 priority_update_order,
@@ -805,6 +818,13 @@ impl<Tracer: SimulationTracer, PartialBlockExecutionTracerType: PartialBlockExec
             }));
         }
 
+        // Register the unwritten PU slots only after every PU has committed,
+        // so SLOADs done by the PUs themselves don't pollute the recording —
+        // we only want to see what the order reads.
+        for slot in &unwritten_priorit_update_slots {
+            pu_storage_tracker.track_slot(slot.clone());
+        }
+
         let exec_result = fork.commit_order(
             &order.order,
             self.space_state,
@@ -836,6 +856,24 @@ impl<Tracer: SimulationTracer, PartialBlockExecutionTracerType: PartialBlockExec
             });
         }
 
+        // Verify every tracked PU slot was actually read on the surviving
+        // call path. Slots only surfaced through reverted subcalls (or not
+        // read at all) mean the owning PU is unused — fail the whole commit
+        // so the caller can re-plan.
+        let unused_slots: Vec<(SlotKey, UsedStorageSlotStatus)> = pu_tracer
+            .classification()
+            .into_iter()
+            .filter(|(_, status)| !matches!(status, UsedStorageSlotStatus::Read))
+            .collect();
+        if !unused_slots.is_empty() {
+            fork.rollback(rollback);
+            self.space_state = initial_space_state;
+            return Ok(OrderCommitResult {
+                priority_updates,
+                order: Err(ExecutionError::PriorityUpdatesNotUsed(unused_slots)),
+            });
+        }
+
         for priority_update in priority_updates.iter().flatten() {
             self.coinbase_profit += priority_update.coinbase_profit;
             self.executed_tx_infos

crates/rbuilder/src/building/priority_update/mod.rs

@@ -1,8 +1,6 @@
 use ahash::{HashMap, HashSet};
 use alloy_primitives::U256;
-use rbuilder_primitives::{
-    evm_inspector::SlotKey, Order, OrderId, PriorityUpdateClass, SimulatedOrder,
-};
+use rbuilder_primitives::{evm_inspector::SlotKey, OrderId, PriorityUpdateClass, SimulatedOrder};
 use std::sync::Arc;
 use tracing::error;
 
@@ -85,39 +83,42 @@ impl PriorityUpdatePool {
         orders
     }
 
-    /// Priority-update orders that touch any of the slots in `read_slots`.
-    ///
-    /// For each read slot: if the slot was already written in the in-block
-    /// bundle state, the PU is not needed for this slot — skip it. Otherwise
-    /// surface the PU that owns the slot.
-    pub fn get_updates<DB>(
-        &self,
-        current_block_state: &BlockState<DB>,
-        read_slots: &[SlotKey],
-    ) -> Vec<&Order> {
+    /// Priority-update orders owning any of the slots in `read_slots`. The
+    /// caller is adviced to filter out slots already written in the current
+    /// bundle state via [`select_unwritten_slots`] beforehand.
+    pub fn get_updates(&self, read_slots: &[SlotKey]) -> Vec<Arc<SimulatedOrder>> {
         if read_slots.is_empty() || self.orders.is_empty() {
             return Vec::new();
         }
         let mut matched: HashSet<OrderId> = HashSet::default();
-        let mut result: Vec<&Order> = Vec::new();
+        let mut result: Vec<Arc<SimulatedOrder>> = Vec::new();
         for slot in read_slots {
-            if slot_overwritten_in_bundle(current_block_state, slot) {
-                continue;
-            }
             let Some(order_id) = self.pending.order_for_slot(slot) else {
                 continue;
             };
             if !matched.insert(order_id) {
                 continue;
             }
             if let Some(sim) = self.orders.get(&order_id) {
-                result.push(sim.order.as_ref());
+                result.push(Arc::clone(sim));
             }
         }
         result
     }
 }
 
+/// Returns the subset of `slots` whose address/key has not been written in
+/// the current in-block bundle state. Used as a prefilter before
+/// [`PriorityUpdatePool::get_updates`] so already-overwritten slots don't
+/// pull in PUs that are no longer needed.
+pub fn select_unwritten_slots<DB>(state: &BlockState<DB>, slots: &[SlotKey]) -> Vec<SlotKey> {
+    slots
+        .iter()
+        .filter(|slot| !slot_overwritten_in_bundle(state, slot))
+        .cloned()
+        .collect()
+}
+
 fn slot_overwritten_in_bundle<DB>(state: &BlockState<DB>, slot: &SlotKey) -> bool {
     let Some(account) = state.bundle_state().state.get(&slot.address) else {
         return false;