only allow builder coinbase

Author: dvush

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

@@ -123,7 +123,7 @@ impl<ConfigType: LiveBuilderConfig>
             self.blocklist.clone(),
             signer.address,
             self.block_data.winning_bid_trace.proposer_fee_recipient,
-            Some(signer),
+            signer,
             Arc::new(MockRootHasher {}),
             self.config.base_config().evm_caching_enable,
         ))

crates/rbuilder/src/backtest/execute.rs

@@ -78,7 +78,7 @@ where
         blocklist,
         builder_signer.address,
         block_data.winning_bid_trace.proposer_fee_recipient,
-        Some(builder_signer),
+        builder_signer,
         Arc::from(provider.root_hasher(parent_num_hash)?),
         evm_caching_enable,
     );

crates/rbuilder/src/backtest/restore_landed_orders/resim_landed_block.rs

@@ -5,7 +5,7 @@ use crate::{
         ThreadBlockBuildingContext,
     },
     provider::StateProviderFactory,
-    utils::{extract_onchain_block_txs, find_suggested_fee_recipient, signed_uint_delta},
+    utils::{extract_onchain_block_txs, find_suggested_fee_recipient, signed_uint_delta, Signer},
 };
 use ahash::{HashMap, HashSet};
 use alloy_primitives::{TxHash, B256, I256};
@@ -45,14 +45,16 @@ where
     let coinbase = onchain_block.header.beneficiary;
     let parent_num_hash = onchain_block.header.parent_num_hash();
 
+    let builder_signer = Signer::random(); // signer will not be used here as we just replay onchain transactions
+
     let ctx = BlockBuildingContext::from_onchain_block(
         onchain_block,
         chain_spec,
         None,
         HashSet::default(),
         coinbase,
         suggested_fee_recipient,
-        None,
+        builder_signer,
         Arc::from(provider.root_hasher(parent_num_hash)?),
         false,
     );

crates/rbuilder/src/bin/debug-bench-machine.rs

@@ -12,7 +12,7 @@ use rbuilder::{
     },
     live_builder::{base_config::load_config_toml_and_env, cli::LiveBuilderConfig, config::Config},
     provider::StateProviderFactory,
-    utils::{extract_onchain_block_txs, find_suggested_fee_recipient, http_provider},
+    utils::{extract_onchain_block_txs, find_suggested_fee_recipient, http_provider, Signer},
 };
 use reth_provider::StateProvider;
 use std::{path::PathBuf, sync::Arc, time::Instant};
@@ -72,7 +72,7 @@ async fn main() -> eyre::Result<()> {
         Default::default(),
         coinbase,
         suggested_fee_recipient,
-        None,
+        Signer::random(),
         Arc::from(provider_factory.root_hasher(parent_num_hash)?),
         config.base_config().evm_caching_enable,
     );

crates/rbuilder/src/bin/run-bundle-on-prefix.rs

@@ -137,7 +137,7 @@ impl LandedBlockInfo {
             Default::default(),
             coinbase,
             suggested_fee_recipient,
-            Some(signer),
+            signer,
             Arc::new(MockRootHasher {}),
             false,
         ))

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

@@ -55,9 +55,6 @@ pub trait BlockBuildingHelper: Send + Sync {
         failed_orders_statistics: OrderStatistics,
     );
 
-    /// Only if can_add_payout_tx you can pass Some(payout_tx_value) to finalize_block (a little ugly could be improved...)
-    fn can_add_payout_tx(&self) -> bool;
-
     /// Accumulated coinbase delta - gas cost of final payout tx (if can_add_payout_tx).
     /// This is the maximum profit that can reach the final fee recipient (max bid!).
     /// Maximum payout_tx_value value to pass to finalize_block.
@@ -70,7 +67,7 @@ pub trait BlockBuildingHelper: Send + Sync {
     fn finalize_block(
         self: Box<Self>,
         local_ctx: &mut ThreadBlockBuildingContext,
-        payout_tx_value: Option<U256>,
+        payout_tx_value: U256,
         seen_competition_bid: Option<U256>,
     ) -> Result<FinalizeBlockResult, BlockBuildingHelperError>;
 
@@ -129,8 +126,7 @@ pub struct BlockBuildingHelperFromProvider<
     block_state: BlockState,
     partial_block: PartialBlock<GasUsedSimulationTracer, PartialBlockExecutionTracerType>,
     /// Gas reserved for the final payout txs from coinbase to fee recipient.
-    /// None means we don't need this final tx since coinbase == fee recipient.
-    payout_tx_gas: Option<u64>,
+    payout_tx_gas: u64,
     /// Name of the builder that pregenerated this block.
     /// Might be ambiguous if several building parts were involved...
     builder_name: String,
@@ -154,8 +150,6 @@ pub enum BlockBuildingHelperError {
     BundleConsistencyCheckFailed(#[from] BuiltBlockTraceError),
     #[error("Error finalizing block: {0}")]
     FinalizeError(#[from] FinalizeError),
-    #[error("Payout tx not allowed for block")]
-    PayoutTxNotAllowed,
     #[error("Provider historical block hashes error: {0}")]
     HistoricalBlockError(#[from] HistoricalBlockError),
 }
@@ -235,19 +229,15 @@ impl<
         partial_block
             .pre_block_call(&building_ctx, local_ctx, &mut block_state)
             .map_err(|_| BlockBuildingHelperError::PreBlockCallFailed)?;
-        let payout_tx_gas = if building_ctx.coinbase_is_suggested_fee_recipient() {
-            None
-        } else {
-            let payout_tx_space = estimate_payout_gas_limit(
-                building_ctx.attributes.suggested_fee_recipient,
-                &building_ctx,
-                local_ctx,
-                &mut block_state,
-                BlockSpace::ZERO,
-            )?;
-            partial_block.reserve_block_space(payout_tx_space);
-            Some(payout_tx_space.gas())
-        };
+        let payout_tx_space = estimate_payout_gas_limit(
+            building_ctx.attributes.suggested_fee_recipient,
+            &building_ctx,
+            local_ctx,
+            &mut block_state,
+            BlockSpace::ZERO,
+        )?;
+        partial_block.reserve_block_space(payout_tx_space);
+        let payout_tx_gas = payout_tx_space.gas();
 
         let mut built_block_trace = BuiltBlockTrace::new();
         built_block_trace.available_orders_statistics = available_orders_statistics;
@@ -296,8 +286,6 @@ impl<
             blobs,
             gas_used,
             sim_gas_used,
-            use_suggested_fee_recipient_as_coinbase =
-                building_ctx.coinbase_is_suggested_fee_recipient(),
             "Built block",
         );
     }
@@ -306,31 +294,20 @@ impl<
     fn finalize_block_execution(
         &mut self,
         local_ctx: &mut ThreadBlockBuildingContext,
-        payout_tx_value: Option<U256>,
+        payout_tx_value: U256,
     ) -> Result<(), BlockBuildingHelperError> {
         self.built_block_trace.coinbase_reward = self.partial_block.coinbase_profit;
 
-        let (bid_value, true_value, use_last_tx_payment) =
-            if let Some((payout_tx_gas, payout_tx_value)) = self.payout_tx_gas.zip(payout_tx_value)
-            {
-                self.partial_block.insert_refunds_and_proposer_payout_tx(
-                    payout_tx_gas,
-                    payout_tx_value,
-                    &self.building_ctx,
-                    local_ctx,
-                    &mut self.block_state,
-                )?;
-                (payout_tx_value, self.true_block_value()?, true)
-            } else {
-                (
-                    self.partial_block.coinbase_profit,
-                    self.partial_block.coinbase_profit,
-                    false,
-                )
-            };
+        self.partial_block.insert_refunds_and_proposer_payout_tx(
+            self.payout_tx_gas,
+            payout_tx_value,
+            &self.building_ctx,
+            local_ctx,
+            &mut self.block_state,
+        )?;
+
+        let (bid_value, true_value) = (payout_tx_value, self.true_block_value()?);
 
-        // Since some extra money might arrived directly the suggested_fee_recipient (when suggested_fee_recipient != coinbase)
-        // we check the fee_recipient delta and make our bid include that! This is supposed to be what the relay will check.
         let fee_recipient_balance_after = self.block_state.balance(
             self.building_ctx.attributes.suggested_fee_recipient,
             &self.building_ctx.shared_cached_reads,
@@ -340,18 +317,7 @@ impl<
             .checked_sub(self._fee_recipient_balance_start)
             .unwrap_or_default();
 
-        if use_last_tx_payment {
-            self.built_block_trace.bid_value = max(bid_value, fee_recipient_balance_diff);
-        } else {
-            // When the coinbase address is the fee recipient, we exclusively use fee_recipient_balance_diff
-            // since this is the value used by validation nodes
-            //
-            // Using fee_recipient_balance_diff may cause block validation failures in certain edge cases
-            // Example: If the fee recipient is a contract that sweeps its balance to another address on each call,
-            // and we include a bundle paying directly to coinbase, the fee recipient balance would be 0
-            // causing validation nodes to reject the block
-            self.built_block_trace.bid_value = fee_recipient_balance_diff;
-        }
+        self.built_block_trace.bid_value = max(bid_value, fee_recipient_balance_diff);
         self.built_block_trace.true_bid_value = true_value;
         Ok(())
     }
@@ -388,8 +354,6 @@ impl<
                     )
                 }
                 Err(err) => {
-                    self.built_block_trace
-                        .modify_payment_when_no_signer_error(&err);
                     self.built_block_trace.add_failed_order(order);
                     (Ok(Err(err)), false)
                 }
@@ -409,29 +373,18 @@ impl<
         self.built_block_trace.orders_closed_at = orders_closed_at;
     }
 
-    fn can_add_payout_tx(&self) -> bool {
-        !self.building_ctx.coinbase_is_suggested_fee_recipient()
-    }
-
     fn true_block_value(&self) -> Result<U256, BlockBuildingHelperError> {
-        if let Some(payout_tx_gas) = self.payout_tx_gas {
-            Ok(self
-                .partial_block
-                .get_proposer_payout_tx_value(payout_tx_gas, &self.building_ctx)?)
-        } else {
-            Ok(self.partial_block.coinbase_profit)
-        }
+        Ok(self
+            .partial_block
+            .get_proposer_payout_tx_value(self.payout_tx_gas, &self.building_ctx)?)
     }
 
     fn finalize_block(
         mut self: Box<Self>,
         local_ctx: &mut ThreadBlockBuildingContext,
-        payout_tx_value: Option<U256>,
+        payout_tx_value: U256,
         seen_competition_bid: Option<U256>,
     ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
-        if payout_tx_value.is_some() && self.building_ctx.coinbase_is_suggested_fee_recipient() {
-            return Err(BlockBuildingHelperError::PayoutTxNotAllowed);
-        }
         let start_time = Instant::now();
         let step_start = Instant::now();
 

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

@@ -195,10 +195,6 @@ impl BlockBuildingHelper for BlockBuildingHelperStatsLogger<'_> {
             .set_trace_orders_closed_at(orders_closed_at);
     }
 
-    fn can_add_payout_tx(&self) -> bool {
-        self.block_building_helper.can_add_payout_tx()
-    }
-
     fn true_block_value(
         &self,
     ) -> Result<alloy_primitives::U256, super::block_building_helper::BlockBuildingHelperError>
@@ -209,7 +205,7 @@ impl BlockBuildingHelper for BlockBuildingHelperStatsLogger<'_> {
     fn finalize_block(
         self: Box<Self>,
         _local_ctx: &mut crate::building::ThreadBlockBuildingContext,
-        _payout_tx_value: Option<alloy_primitives::U256>,
+        _payout_tx_value: alloy_primitives::U256,
         _seen_competition_bid: Option<alloy_primitives::U256>,
     ) -> Result<
         super::block_building_helper::FinalizeBlockResult,

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

@@ -27,20 +27,18 @@ use super::{
 pub struct MockBlockBuildingHelper {
     built_block_trace: BuiltBlockTrace,
     block_building_context: BlockBuildingContext,
-    can_add_payout_tx: bool,
     builder_name: String,
 }
 
 impl MockBlockBuildingHelper {
-    pub fn new(true_block_value: U256, can_add_payout_tx: bool) -> Self {
+    pub fn new(true_block_value: U256) -> Self {
         let built_block_trace = BuiltBlockTrace {
             true_bid_value: true_block_value,
             ..Default::default()
         };
         Self {
             built_block_trace,
             block_building_context: BlockBuildingContext::dummy_for_testing(),
-            can_add_payout_tx,
             builder_name: "Mock".to_string(),
         }
     }
@@ -79,27 +77,19 @@ impl BlockBuildingHelper for MockBlockBuildingHelper {
         self.built_block_trace.orders_closed_at = orders_closed_at;
     }
 
-    fn can_add_payout_tx(&self) -> bool {
-        self.can_add_payout_tx
-    }
-
     fn true_block_value(&self) -> Result<U256, BlockBuildingHelperError> {
         Ok(self.built_block_trace.true_bid_value)
     }
 
     fn finalize_block(
         mut self: Box<Self>,
         _local_ctx: &mut ThreadBlockBuildingContext,
-        payout_tx_value: Option<U256>,
+        payout_tx_value: U256,
         seen_competition_bid: Option<U256>,
     ) -> Result<FinalizeBlockResult, BlockBuildingHelperError> {
         self.built_block_trace.update_orders_sealed_at();
         self.built_block_trace.seen_competition_bid = seen_competition_bid;
-        self.built_block_trace.bid_value = if let Some(payout_tx_value) = payout_tx_value {
-            payout_tx_value
-        } else {
-            self.built_block_trace.true_bid_value
-        };
+        self.built_block_trace.bid_value = payout_tx_value;
         let block = Block {
             builder_name: "BlockBuildingHelper".to_string(),
             trace: self.built_block_trace,