simple 2 step fin

Author: dvush

crates/rbuilder/src/building/builders/block_building_helper.rs

@@ -80,6 +80,18 @@ pub trait BlockBuildingHelper: Send + Sync {
     /// Name of the builder that pregenerated this block.
     /// BE CAREFUL: Might be ambiguous if several building parts were involved...
     fn builder_name(&self) -> &str;
+
+    fn prefinalize_block(
+        &mut self,
+        local_ctx: &mut ThreadBlockBuildingContext,
+    ) -> Result<(), BlockBuildingHelperError>;
+
+    fn finalize_prefinalized_block(
+        &mut self,
+        local_ctx: &mut ThreadBlockBuildingContext,
+        payout_tx_value: U256,
+        seen_competition_bid: Option<U256>,
+    ) -> Result<FinalizeBlockResult, BlockBuildingHelperError>;
 }
 
 /// Wraps a BlockBuildingHelper with a valid true_block_value which makes it ready to bid.
@@ -134,6 +146,13 @@ pub struct BlockBuildingHelperFromProvider<
     built_block_trace: BuiltBlockTrace,
     /// Token to cancel in case of fatal error (if we believe that it's impossible to build for this block).
     cancel_on_fatal_error: CancellationToken,
+
+    prefinalize_state: Option<PrefinalizeState>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PrefinalizeState {
+    builder_nonce: u64,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -152,6 +171,8 @@ pub enum BlockBuildingHelperError {
     FinalizeError(#[from] FinalizeError),
     #[error("Provider historical block hashes error: {0}")]
     HistoricalBlockError(#[from] HistoricalBlockError),
+    #[error("Block is not prefinalized")]
+    BlockIsNotPrefinalized,
 }
 
 impl BlockBuildingHelperError {
@@ -250,6 +271,7 @@ impl<
             building_ctx,
             built_block_trace,
             cancel_on_fatal_error,
+            prefinalize_state: None,
         })
     }
 
@@ -472,4 +494,109 @@ impl<
         self.built_block_trace
             .set_filtered_build_statistics(considered_orders_statistics, failed_orders_statistics);
     }
+
+    // prepare block for fast finalization
+    // executes the most expensive part of finalization so that adding a bid transaction is fast
+    fn prefinalize_block(
+        &mut self,
+        local_ctx: &mut ThreadBlockBuildingContext,
+    ) -> Result<(), BlockBuildingHelperError> {
+        self.built_block_trace
+            .verify_bundle_consistency(&self.building_ctx.blocklist)?;
+
+        let builder_nonce = self
+            .partial_block
+            .insert_combined_refunds_two_step_finalize(
+                &self.building_ctx,
+                local_ctx,
+                &mut self.block_state,
+            )?;
+
+        self.prefinalize_state = Some(PrefinalizeState { builder_nonce });
+
+        Ok(())
+    }
+
+    fn finalize_prefinalized_block(
+        &mut self,
+        local_ctx: &mut ThreadBlockBuildingContext,
+        payout_tx_value: U256,
+        seen_competition_bid: Option<U256>,
+    ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
+        let start_time = Instant::now();
+
+        let prefinalize_state = if let Some(state) = self.prefinalize_state.as_mut() {
+            state
+        } else {
+            return Err(BlockBuildingHelperError::BlockIsNotPrefinalized);
+        };
+
+        let mut partial_block = self.partial_block.clone();
+        let mut block_state = self.block_state.clone();
+
+        let payout_tx_gas = self.payout_tx_gas;
+        partial_block.insert_refund_tx_two_step_finalize(
+            &self.building_ctx,
+            local_ctx,
+            &mut block_state,
+            payout_tx_gas,
+            payout_tx_value,
+            prefinalize_state.builder_nonce,
+        )?;
+
+        let fee_recipient_balance_after = block_state.balance(
+            self.building_ctx.attributes.suggested_fee_recipient,
+            &self.building_ctx.shared_cached_reads,
+            &mut local_ctx.cached_reads,
+        )?;
+        let fee_recipient_balance_diff = fee_recipient_balance_after
+            .checked_sub(self._fee_recipient_balance_start)
+            .unwrap_or_default();
+
+        self.built_block_trace.bid_value = max(payout_tx_value, fee_recipient_balance_diff);
+        self.built_block_trace.true_bid_value =
+            partial_block.get_proposer_payout_tx_value(payout_tx_gas, &self.building_ctx)?;
+
+        let sim_gas_used = partial_block.tracer.used_gas;
+        let block_number = self.building_context().block();
+
+        let finalized_block =
+            match partial_block.finalize(block_state, &self.building_ctx, local_ctx) {
+                Ok(finalized_block) => finalized_block,
+                Err(err) => {
+                    if err.is_consistent_db_view_err() {
+                        debug!(
+                            block_number,
+                            payload_id = self.building_ctx.payload_id,
+                            "Can't build on this head, cancelling slot"
+                        );
+                        self.cancel_on_fatal_error.cancel();
+                    }
+                    return Err(BlockBuildingHelperError::FinalizeError(err));
+                }
+            };
+
+        self.built_block_trace.update_orders_sealed_at();
+        self.built_block_trace.root_hash_time = finalized_block.root_hash_time;
+        self.built_block_trace.finalize_time = start_time.elapsed();
+        self.built_block_trace.seen_competition_bid = seen_competition_bid;
+
+        Self::trace_finalized_block(
+            &finalized_block,
+            &self.builder_name,
+            &self.building_ctx,
+            &self.built_block_trace,
+            sim_gas_used,
+        );
+
+        let block = Block {
+            trace: self.built_block_trace.clone(),
+            sealed_block: finalized_block.sealed_block,
+            txs_blobs_sidecars: finalized_block.txs_blob_sidecars,
+            builder_name: self.builder_name.clone(),
+            execution_requests: finalized_block.execution_requests,
+            bid_adjustments: finalized_block.bid_adjustments,
+        };
+        Ok(FinalizeBlockResult { block })
+    }
 }

crates/rbuilder/src/building/builders/block_building_helper_stats_logger.rs

@@ -7,11 +7,13 @@ use std::{
 use alloy_primitives::{utils::format_ether, U256};
 
 use crate::{
-    building::builders::block_building_helper::BlockBuildingHelper,
+    building::{builders::block_building_helper::BlockBuildingHelper, ThreadBlockBuildingContext},
     live_builder::order_input::mempool_txs_detector::MempoolTxsDetector,
     primitives::{order_statistics::OrderStatistics, OrderId, SimulatedOrder},
 };
 
+use super::block_building_helper::{BlockBuildingHelperError, FinalizeBlockResult};
+
 /// Wraps a BlockBuildingHelper and stores info about every commit_order as lightweight as possible.
 pub struct BlockBuildingHelperStatsLogger<'a> {
     block_building_helper: &'a mut dyn BlockBuildingHelper,
@@ -162,7 +164,7 @@ impl BlockBuildingHelper for BlockBuildingHelperStatsLogger<'_> {
 
     fn commit_order(
         &mut self,
-        local_ctx: &mut crate::building::ThreadBlockBuildingContext,
+        local_ctx: &mut ThreadBlockBuildingContext,
         order: &crate::primitives::SimulatedOrder,
         result_filter: &dyn Fn(
             &crate::primitives::SimValue,
@@ -207,10 +209,7 @@ impl BlockBuildingHelper for BlockBuildingHelperStatsLogger<'_> {
         _local_ctx: &mut crate::building::ThreadBlockBuildingContext,
         _payout_tx_value: alloy_primitives::U256,
         _seen_competition_bid: Option<alloy_primitives::U256>,
-    ) -> Result<
-        super::block_building_helper::FinalizeBlockResult,
-        super::block_building_helper::BlockBuildingHelperError,
-    > {
+    ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
         panic!("finalize_block not implemented. This is only for testing.");
     }
 
@@ -234,4 +233,20 @@ impl BlockBuildingHelper for BlockBuildingHelperStatsLogger<'_> {
         self.block_building_helper
             .set_filtered_build_statistics(considered_orders_statistics, failed_orders_statistics);
     }
+
+    fn prefinalize_block(
+        &mut self,
+        _local_ctx: &mut ThreadBlockBuildingContext,
+    ) -> Result<(), BlockBuildingHelperError> {
+        unimplemented!()
+    }
+
+    fn finalize_prefinalized_block(
+        &mut self,
+        _local_ctx: &mut ThreadBlockBuildingContext,
+        _payout_tx_value: U256,
+        _seen_competition_bid: Option<U256>,
+    ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
+        unimplemented!()
+    }
 }

crates/rbuilder/src/building/builders/mock_block_building_helper.rs

@@ -122,6 +122,22 @@ impl BlockBuildingHelper for MockBlockBuildingHelper {
         self.built_block_trace
             .set_filtered_build_statistics(considered_orders_statistics, failed_orders_statistics);
     }
+
+    fn prefinalize_block(
+        &mut self,
+        _local_ctx: &mut ThreadBlockBuildingContext,
+    ) -> Result<(), BlockBuildingHelperError> {
+        unimplemented!()
+    }
+
+    fn finalize_prefinalized_block(
+        &mut self,
+        _local_ctx: &mut ThreadBlockBuildingContext,
+        _payout_tx_value: U256,
+        _seen_competition_bid: Option<U256>,
+    ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
+        unimplemented!()
+    }
 }
 
 #[derive(Debug)]

crates/rbuilder/src/building/mod.rs

@@ -910,6 +910,100 @@ impl<Tracer: SimulationTracer, PartialBlockExecutionTracerType: PartialBlockExec
         Ok(())
     }
 
+    pub fn insert_combined_refunds_two_step_finalize(
+        &mut self,
+        ctx: &BlockBuildingContext,
+        local_ctx: &mut ThreadBlockBuildingContext,
+        state: &mut BlockState,
+    ) -> Result<u64, InsertPayoutTxErr> {
+        let builder_signer = &ctx.builder_signer;
+        self.free_reserved_block_space();
+        let mut nonce = state
+            .nonce(
+                builder_signer.address,
+                &ctx.shared_cached_reads,
+                &mut local_ctx.cached_reads,
+            )
+            .map_err(CriticalCommitOrderError::Reth)?;
+
+        let mut fork = PartialBlockFork::new(state, ctx, local_ctx).with_tracer(&mut self.tracer);
+
+        for (refund_recipient, refund_amount) in &self.combined_refunds {
+            let refund_recipient_code_hash = fork
+                .state
+                .code_hash(
+                    *refund_recipient,
+                    &ctx.shared_cached_reads,
+                    &mut fork.local_ctx.cached_reads,
+                )
+                .map_err(CriticalCommitOrderError::Reth)?;
+            if refund_recipient_code_hash != KECCAK_EMPTY {
+                error!(%refund_recipient_code_hash, %refund_recipient, %refund_amount, "Refund recipient has code, skipping refund");
+                continue;
+            }
+
+            let refund_tx = TransactionSignedEcRecoveredWithBlobs::new_no_blobs(create_payout_tx(
+                ctx.chain_spec.as_ref(),
+                ctx.evm_env.block_env.basefee,
+                builder_signer,
+                nonce,
+                *refund_recipient,
+                BASE_TX_GAS,
+                *refund_amount,
+            )?)
+            .unwrap();
+            let refund_result = fork.commit_tx(&refund_tx, self.space_state)??;
+            if !refund_result.tx_info.receipt.success {
+                return Err(InsertPayoutTxErr::CombinedRefundTxReverted);
+            }
+
+            self.space_state
+                .use_space(refund_result.space_used(), refund_result.blob_gas_used);
+            self.executed_tx_infos.push(refund_result.tx_info);
+
+            nonce += 1;
+        }
+
+        Ok(nonce)
+    }
+
+    pub fn insert_refund_tx_two_step_finalize(
+        &mut self,
+        ctx: &BlockBuildingContext,
+        local_ctx: &mut ThreadBlockBuildingContext,
+        state: &mut BlockState,
+        gas_limit: u64,
+        value: U256,
+        nonce: u64,
+    ) -> Result<(), InsertPayoutTxErr> {
+        let builder_signer = &ctx.builder_signer;
+
+        let mut fork = PartialBlockFork::new(state, ctx, local_ctx).with_tracer(&mut self.tracer);
+
+        let tx = create_payout_tx(
+            ctx.chain_spec.as_ref(),
+            ctx.evm_env.block_env.basefee,
+            builder_signer,
+            nonce,
+            ctx.attributes.suggested_fee_recipient,
+            gas_limit,
+            value,
+        )?;
+        // payout tx has no blobs so it's safe to unwrap
+        let tx = TransactionSignedEcRecoveredWithBlobs::new_no_blobs(tx).unwrap();
+        let exec_result = fork.commit_tx(&tx, self.space_state)?;
+        let ok_result = exec_result?;
+        if !ok_result.tx_info.receipt.success {
+            return Err(InsertPayoutTxErr::PayoutTxReverted);
+        }
+
+        self.space_state
+            .use_space(ok_result.space_used(), ok_result.blob_gas_used);
+        self.executed_tx_infos.push(ok_result.tx_info);
+
+        Ok(())
+    }
+
     /// returns (requests, withdrawals_root)
     pub fn process_requests(
         &self,