add tx simulation

Author: avalonche

crates/op-rbuilder/src/builders/builder_tx.rs

@@ -6,13 +6,17 @@ use alloy_primitives::{
 };
 use core::fmt::Debug;
 use op_alloy_consensus::OpTypedTransaction;
+use op_revm::OpTransactionError;
 use reth_evm::{eth::receipt_builder::ReceiptBuilderCtx, ConfigureEvm, Evm};
 use reth_node_api::PayloadBuilderError;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::Recovered;
-use reth_provider::ProviderError;
+use reth_provider::{ProviderError, StateProvider};
 use reth_revm::State;
-use revm::{context::result::ResultAndState, Database, DatabaseCommit};
+use revm::{
+    context::result::{EVMError, ResultAndState},
+    Database, DatabaseCommit,
+};
 use tracing::{debug, warn};
 
 use crate::{
@@ -48,6 +52,12 @@ impl From<secp256k1::Error> for BuilderTransactionError {
     }
 }
 
+impl From<EVMError<ProviderError, OpTransactionError>> for BuilderTransactionError {
+    fn from(error: EVMError<ProviderError, OpTransactionError>) -> Self {
+        BuilderTransactionError::EvmExecutionError(Box::new(error))
+    }
+}
+
 impl From<BuilderTransactionError> for PayloadBuilderError {
     fn from(error: BuilderTransactionError) -> Self {
         match error {
@@ -60,30 +70,30 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
 }
 
 pub trait BuilderTransactions: Debug {
-    fn simulate_builder_txs<DB, Extra: Debug + Default>(
+    fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
+        state_provider: impl StateProvider,
         info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<DB>,
-    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>
-    where
-        DB: Database<Error = ProviderError>;
+        db: &mut State<impl Database<Error = ProviderError>>,
+    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>;
 
-    fn add_builder_txs<DB, Extra: Debug + Default>(
+    fn add_builder_txs<Extra: Debug + Default>(
         &self,
+        state_provider: impl StateProvider,
         info: &mut ExecutionInfo<Extra>,
         builder_ctx: &OpPayloadBuilderCtx,
-        db: &mut State<DB>,
-    ) -> Result<(), BuilderTransactionError>
-    where
-        DB: Database<Error = ProviderError>,
-    {
+        db: &mut State<impl Database<Error = ProviderError>>,
+    ) -> Result<(), BuilderTransactionError> {
         {
             let mut evm = builder_ctx
                 .evm_config
                 .evm_with_env(&mut *db, builder_ctx.evm_env.clone());
+
             let mut invalid: HashSet<Address> = HashSet::new();
-            let builder_txs = self.simulate_builder_txs(info, builder_ctx, evm.db_mut())?;
+            // simulate builder txs on the top of block state
+            let builder_txs =
+                self.simulate_builder_txs(state_provider, info, builder_ctx, evm.db_mut())?;
             for builder_tx in builder_txs {
                 if invalid.contains(&builder_tx.signed_tx.signer()) {
                     debug!(target: "payload_builder", tx_hash = ?builder_tx.signed_tx.tx_hash(), "builder signer invalid as previous builder tx reverted");
@@ -143,6 +153,29 @@ impl StandardBuilderTx {
         Self { signer }
     }
 
+    pub fn simulate_builder_txs(
+        &self,
+        ctx: &OpPayloadBuilderCtx,
+        db: &mut State<impl Database<Error = ProviderError>>,
+    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
+        match self.signer {
+            Some(signer) => {
+                let message: Vec<u8> = format!("Block Number: {}", ctx.block_number()).into_bytes();
+                let gas_used = self.estimate_builder_tx_gas(&message);
+                let signed_tx = self.signed_builder_tx(ctx, db, signer, gas_used, message)?;
+                let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
+                    signed_tx.encoded_2718().as_slice(),
+                );
+                Ok(vec![BuilderTransactionCtx {
+                    gas_used,
+                    da_size,
+                    signed_tx,
+                }])
+            }
+            None => Ok(vec![]),
+        }
+    }
+
     fn estimate_builder_tx_gas(&self, input: &[u8]) -> u64 {
         // Count zero and non-zero bytes
         let (zero_bytes, nonzero_bytes) = input.iter().fold((0, 0), |(zeros, nonzeros), &byte| {
@@ -202,30 +235,13 @@ impl StandardBuilderTx {
 }
 
 impl BuilderTransactions for StandardBuilderTx {
-    fn simulate_builder_txs<DB, Extra: Debug + Default>(
+    fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
+        _state_provider: impl StateProvider,
         _info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<DB>,
-    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>
-    where
-        DB: Database<Error = ProviderError>,
-    {
-        match self.signer {
-            Some(signer) => {
-                let message: Vec<u8> = format!("Block Number: {}", ctx.block_number()).into_bytes();
-                let gas_used = self.estimate_builder_tx_gas(&message);
-                let signed_tx = self.signed_builder_tx(ctx, db, signer, gas_used, message)?;
-                let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
-                    signed_tx.encoded_2718().as_slice(),
-                );
-                Ok(vec![BuilderTransactionCtx {
-                    gas_used,
-                    da_size,
-                    signed_tx,
-                }])
-            }
-            None => Ok(vec![]),
-        }
+        db: &mut State<impl Database<Error = ProviderError>>,
+    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
+        self.simulate_builder_txs(ctx, db)
     }
 }

crates/op-rbuilder/src/builders/flashblocks/payload.rs

@@ -249,13 +249,14 @@ where
 
         // If we have payload with txpool we add first builder tx right after deposits
         if !ctx.attributes().no_tx_pool {
-            self.builder_tx.add_builder_txs(&mut info, &ctx, &mut db)?;
+            self.builder_tx
+                .add_builder_txs(&state_provider, &mut info, &ctx, &mut db)?;
         }
 
         // We subtract gas limit and da limit for builder transaction from the whole limit
         let builder_txs = self
             .builder_tx
-            .simulate_builder_txs(&mut info, &ctx, &mut db)
+            .simulate_builder_txs(&state_provider, &mut info, &ctx, &mut db)
             .map_err(|err| PayloadBuilderError::Other(Box::new(err)))?;
         let builder_tx_gas = builder_txs.iter().fold(0, |acc, tx| acc + tx.gas_used);
         let builder_tx_da_size: u64 = builder_txs.iter().fold(0, |acc, tx| acc + tx.da_size);
@@ -454,7 +455,7 @@ where
                     let mut db = State::builder()
                         .with_database(state)
                         .with_bundle_update()
-                        .with_bundle_prestate(bundle_state)
+                        .with_bundle_prestate(bundle_state.clone())
                         .build();
 
                     let best_txs_start_time = Instant::now();
@@ -495,7 +496,7 @@ where
                     // If it is the last flashblocks, add the builder txn to the block if enabled
                     invoke_on_last_flashblock(flashblock_count, last_flashblock, || {
                         self.builder_tx
-                            .add_builder_txs(&mut info, &ctx, &mut db)
+                            .add_builder_txs(&state_provider, &mut info, &ctx, &mut db)
                             .map_err(|err| PayloadBuilderError::Other(Box::new(err)))
                     })?;
 

crates/op-rbuilder/src/builders/flashblocks/service.rs

@@ -91,9 +91,7 @@ where
                 }
             };
 
-            if self.0.flashtestations_config.enable_block_proofs {
-                return self.spawn_payload_builder_service(ctx, pool, flashtestations_builder_tx);
-            }
+            return self.spawn_payload_builder_service(ctx, pool, flashtestations_builder_tx);
         }
         self.spawn_payload_builder_service(ctx, pool, StandardBuilderTx { signer })
     }

crates/op-rbuilder/src/builders/standard/payload.rs

@@ -1,3 +1,4 @@
+use super::super::context::OpPayloadBuilderCtx;
 use crate::{
     builders::{generator::BuildArguments, BuilderConfig, BuilderTransactions},
     metrics::OpRBuilderMetrics,
@@ -21,10 +22,7 @@ use reth_optimism_node::{OpBuiltPayload, OpPayloadBuilderAttributes};
 use reth_optimism_primitives::{OpPrimitives, OpTransactionSigned};
 use reth_payload_util::{BestPayloadTransactions, NoopPayloadTransactions, PayloadTransactions};
 use reth_primitives::RecoveredBlock;
-use reth_provider::{
-    ExecutionOutcome, HashedPostStateProvider, ProviderError, StateRootProvider,
-    StorageRootProvider,
-};
+use reth_provider::{ExecutionOutcome, ProviderError, StateProvider};
 use reth_revm::{
     database::StateProviderDatabase, db::states::bundle_state::BundleRetention, State,
 };
@@ -34,8 +32,6 @@ use std::{sync::Arc, time::Instant};
 use tokio_util::sync::CancellationToken;
 use tracing::{error, info, warn};
 
-use super::super::context::OpPayloadBuilderCtx;
-
 /// Optimism's payload builder
 #[derive(Debug, Clone)]
 pub struct StandardOpPayloadBuilder<Pool, Client, BuilderTx, Txs = ()> {
@@ -233,22 +229,18 @@ where
         let builder = OpBuilder::new(best);
 
         let state_provider = self.client.state_by_block_hash(ctx.parent().hash())?;
-        let state = StateProviderDatabase::new(state_provider);
+        let state = StateProviderDatabase::new(&state_provider);
         let metrics = ctx.metrics.clone();
-
         if ctx.attributes().no_tx_pool {
-            let db = State::builder()
-                .with_database(state)
-                .with_bundle_update()
-                .build();
-            builder.build(db, ctx, self.builder_tx.clone())
+            builder.build(state, &state_provider, ctx, self.builder_tx.clone())
         } else {
             // sequencer mode we can reuse cachedreads from previous runs
-            let db = State::builder()
-                .with_database(cached_reads.as_db_mut(state))
-                .with_bundle_update()
-                .build();
-            builder.build(db, ctx, self.builder_tx.clone())
+            builder.build(
+                cached_reads.as_db_mut(state),
+                &state_provider,
+                ctx,
+                self.builder_tx.clone(),
+            )
         }
         .map(|out| {
             metrics
@@ -298,30 +290,29 @@ pub struct ExecutedPayload {
 
 impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
     /// Executes the payload and returns the outcome.
-    pub fn execute<DB, P, BuilderTx>(
+    pub fn execute<BuilderTx>(
         self,
-        state: &mut State<DB>,
+        state_provider: impl StateProvider,
+        db: &mut State<impl Database<Error = ProviderError>>,
         ctx: &OpPayloadBuilderCtx,
         builder_tx: BuilderTx,
     ) -> Result<BuildOutcomeKind<ExecutedPayload>, PayloadBuilderError>
     where
-        DB: Database<Error = ProviderError> + AsRef<P>,
-        P: StorageRootProvider,
         BuilderTx: BuilderTransactions,
     {
         let Self { best } = self;
         info!(target: "payload_builder", id=%ctx.payload_id(), parent_header = ?ctx.parent().hash(), parent_number = ctx.parent().number, "building new payload");
 
         // 1. apply pre-execution changes
         ctx.evm_config
-            .builder_for_next_block(state, ctx.parent(), ctx.block_env_attributes.clone())
+            .builder_for_next_block(db, ctx.parent(), ctx.block_env_attributes.clone())
             .map_err(PayloadBuilderError::other)?
             .apply_pre_execution_changes()?;
 
         let sequencer_tx_start_time = Instant::now();
 
         // 3. execute sequencer transactions
-        let mut info = ctx.execute_sequencer_transactions(state)?;
+        let mut info = ctx.execute_sequencer_transactions(db)?;
 
         ctx.metrics
             .sequencer_tx_duration
@@ -330,7 +321,7 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
         // 4. if mem pool transactions are requested we execute them
 
         // gas reserved for builder tx
-        let builder_txs = builder_tx.simulate_builder_txs(&mut info, ctx, state)?;
+        let builder_txs = builder_tx.simulate_builder_txs(&state_provider, &mut info, ctx, db)?;
         let builder_tx_gas = builder_txs.iter().fold(0, |acc, tx| acc + tx.gas_used);
         let block_gas_limit = ctx.block_gas_limit().saturating_sub(builder_tx_gas);
         if block_gas_limit == 0 {
@@ -358,7 +349,7 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
             if ctx
                 .execute_best_transactions(
                     &mut info,
-                    state,
+                    db,
                     best_txs,
                     block_gas_limit,
                     block_da_limit,
@@ -370,13 +361,13 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
         }
 
         // Add builder tx to the block
-        builder_tx.add_builder_txs(&mut info, ctx, state)?;
+        builder_tx.add_builder_txs(&state_provider, &mut info, ctx, db)?;
 
         let state_merge_start_time = Instant::now();
 
         // merge all transitions into bundle state, this would apply the withdrawal balance changes
         // and 4788 contract call
-        state.merge_transitions(BundleRetention::Reverts);
+        db.merge_transitions(BundleRetention::Reverts);
 
         ctx.metrics
             .state_transition_merge_duration
@@ -392,26 +383,32 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
     }
 
     /// Builds the payload on top of the state.
-    pub fn build<DB, P, BuilderTx>(
+    pub fn build<BuilderTx>(
         self,
-        mut state: State<DB>,
+        state: impl Database<Error = ProviderError>,
+        state_provider: impl StateProvider,
         ctx: OpPayloadBuilderCtx,
         builder_tx: BuilderTx,
     ) -> Result<BuildOutcomeKind<OpBuiltPayload>, PayloadBuilderError>
     where
-        DB: Database<Error = ProviderError> + AsRef<P>,
-        P: StateRootProvider + HashedPostStateProvider + StorageRootProvider,
         BuilderTx: BuilderTransactions,
     {
-        let ExecutedPayload { info } = match self.execute(&mut state, &ctx, builder_tx)? {
-            BuildOutcomeKind::Better { payload } | BuildOutcomeKind::Freeze(payload) => payload,
-            BuildOutcomeKind::Cancelled => return Ok(BuildOutcomeKind::Cancelled),
-            BuildOutcomeKind::Aborted { fees } => return Ok(BuildOutcomeKind::Aborted { fees }),
-        };
+        let mut db = State::builder()
+            .with_database(state)
+            .with_bundle_update()
+            .build();
+        let ExecutedPayload { info } =
+            match self.execute(&state_provider, &mut db, &ctx, builder_tx)? {
+                BuildOutcomeKind::Better { payload } | BuildOutcomeKind::Freeze(payload) => payload,
+                BuildOutcomeKind::Cancelled => return Ok(BuildOutcomeKind::Cancelled),
+                BuildOutcomeKind::Aborted { fees } => {
+                    return Ok(BuildOutcomeKind::Aborted { fees })
+                }
+            };
 
         let block_number = ctx.block_number();
         let execution_outcome = ExecutionOutcome::new(
-            state.take_bundle(),
+            db.take_bundle(),
             vec![info.receipts],
             block_number,
             Vec::new(),
@@ -432,12 +429,9 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
         // calculate the state root
         let state_root_start_time = Instant::now();
 
-        let state_provider = state.database.as_ref();
         let hashed_state = state_provider.hashed_post_state(execution_outcome.state());
         let (state_root, trie_output) = {
-            state
-                .database
-                .as_ref()
+            state_provider
                 .state_root_with_updates(hashed_state.clone())
                 .inspect_err(|err| {
                     warn!(target: "payload_builder",
@@ -457,7 +451,7 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
             // `l2tol1-message-passer`
             (
                 Some(
-                    isthmus::withdrawals_root(execution_outcome.state(), state.database.as_ref())
+                    isthmus::withdrawals_root(execution_outcome.state(), state_provider)
                         .map_err(PayloadBuilderError::other)?,
                 ),
                 Some(EMPTY_REQUESTS_HASH),