move simumlation calls to builder tx

Author: avalonche

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

@@ -1,29 +1,42 @@
-use alloy_consensus::TxEip1559;
+use alloy_consensus::{Transaction, TxEip1559};
 use alloy_eips::{Encodable2718, eip7623::TOTAL_COST_FLOOR_PER_TOKEN};
 use alloy_evm::Database;
+use alloy_op_evm::OpEvm;
 use alloy_primitives::{
-    Address, B256, Log, TxKind, U256,
-    map::foldhash::{HashSet, HashSetExt},
+    Address, B256, Bytes, TxKind, U256,
+    map::foldhash::{HashMap, HashSet, HashSetExt},
 };
 use core::fmt::Debug;
 use op_alloy_consensus::OpTypedTransaction;
-use op_revm::OpTransactionError;
-use reth_evm::{ConfigureEvm, Evm, eth::receipt_builder::ReceiptBuilderCtx};
+use op_revm::{OpHaltReason, OpTransactionError};
+use reth_evm::{
+    ConfigureEvm, Evm, EvmError, eth::receipt_builder::ReceiptBuilderCtx,
+    precompiles::PrecompilesMap,
+};
 use reth_node_api::PayloadBuilderError;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::Recovered;
 use reth_provider::{ProviderError, StateProvider};
 use reth_revm::{State, database::StateProviderDatabase};
 use revm::{
     DatabaseCommit,
-    context::result::{EVMError, ResultAndState},
+    context::result::{EVMError, ExecutionResult, ResultAndState},
+    inspector::NoOpInspector,
+    state::Account,
 };
 use tracing::warn;
 
 use crate::{
     builders::context::OpPayloadBuilderCtx, primitives::reth::ExecutionInfo, tx_signer::Signer,
 };
 
+#[derive(Debug, Default)]
+pub struct SimulationSuccessResult {
+    pub gas_used: u64,
+    pub output: Bytes,
+    pub state_changes: HashMap<Address, Account>,
+}
+
 #[derive(Debug, Clone)]
 pub struct BuilderTransactionCtx {
     pub gas_used: u64,
@@ -46,6 +59,14 @@ impl BuilderTransactionCtx {
     }
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum InvalidContractDataError {
+    #[error("did not find expected log {0:?} in emitted logs")]
+    InvalidLogs(B256),
+    #[error("could not decode output from contract call")]
+    OutputAbiDecodeError,
+}
+
 /// Possible error variants during construction of builder txs.
 #[derive(Debug, thiserror::Error)]
 pub enum BuilderTransactionError {
@@ -55,9 +76,15 @@ pub enum BuilderTransactionError {
     /// Signature signing fails
     #[error("failed to sign transaction: {0}")]
     SigningError(secp256k1::Error),
-    /// Invalid contract data returned
-    #[error("invalid contract data returned {0}")]
-    InvalidContract(Address),
+    /// Invalid contract errors indicating the contract is incorrect
+    #[error("contract {0} may be incorrect, invalid contract data: {1}")]
+    InvalidContract(Address, InvalidContractDataError),
+    /// Transaction halted execution
+    #[error("transaction halted {0:?}")]
+    TransactionHalted(OpHaltReason),
+    /// Transaction reverted
+    #[error("transaction reverted {0}")]
+    TransactionReverted(Box<dyn core::error::Error + Send + Sync>),
     /// Invalid tx errors during evm execution.
     #[error("invalid transaction error {0}")]
     InvalidTransactionError(Box<dyn core::error::Error + Send + Sync>),
@@ -93,12 +120,13 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
 }
 
 impl BuilderTransactionError {
-    pub fn other<E>(error: E) -> Self
-    where
-        E: core::error::Error + Send + Sync + 'static,
-    {
+    pub fn other(error: impl core::error::Error + Send + Sync + 'static) -> Self {
         BuilderTransactionError::Other(Box::new(error))
     }
+
+    pub fn msg(msg: impl core::fmt::Display) -> Self {
+        Self::Other(msg.to_string().into())
+    }
 }
 
 pub trait BuilderTransactions<ExtraCtx: Debug + Default = (), Extra: Debug + Default = ()> {
@@ -210,6 +238,84 @@ pub trait BuilderTransactions<ExtraCtx: Debug + Default = (), Extra: Debug + Def
 
         Ok(simulation_state)
     }
+
+    fn sign_tx(
+        &self,
+        to: Address,
+        from: Signer,
+        gas_used: Option<u64>,
+        calldata: Bytes,
+        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
+        db: &mut State<impl Database>,
+    ) -> Result<Recovered<OpTransactionSigned>, BuilderTransactionError> {
+        let nonce = get_nonce(db, from.address)?;
+        // Create the EIP-1559 transaction
+        let tx = OpTypedTransaction::Eip1559(TxEip1559 {
+            chain_id: ctx.chain_id(),
+            nonce,
+            // Due to EIP-150, 63/64 of available gas is forwarded to external calls so need to add a buffer
+            gas_limit: gas_used
+                .map(|gas| gas * 64 / 63)
+                .unwrap_or(ctx.block_gas_limit()),
+            max_fee_per_gas: ctx.base_fee().into(),
+            to: TxKind::Call(to),
+            input: calldata,
+            ..Default::default()
+        });
+        Ok(from.sign_tx(tx)?)
+    }
+
+    fn simulate_call(
+        &self,
+        signed_tx: Recovered<OpTransactionSigned>,
+        expected_topic: Option<B256>,
+        revert_handler: impl FnOnce(Bytes) -> BuilderTransactionError,
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<SimulationSuccessResult, BuilderTransactionError> {
+        let ResultAndState { result, state } = match evm.transact(&signed_tx) {
+            Ok(res) => res,
+            Err(err) => {
+                if err.is_invalid_tx_err() {
+                    return Err(BuilderTransactionError::InvalidTransactionError(Box::new(
+                        err,
+                    )));
+                } else {
+                    return Err(BuilderTransactionError::EvmExecutionError(Box::new(err)));
+                }
+            }
+        };
+
+        match result {
+            ExecutionResult::Success {
+                logs,
+                gas_used,
+                output,
+                ..
+            } => {
+                if let Some(topic) = expected_topic
+                    && !logs.iter().any(|log| log.topics().first() == Some(&topic))
+                {
+                    return Err(BuilderTransactionError::InvalidContract(
+                        signed_tx.to().unwrap_or_default(),
+                        InvalidContractDataError::InvalidLogs(topic),
+                    ));
+                }
+                Ok(SimulationSuccessResult {
+                    gas_used,
+                    output: output.into_data(),
+                    state_changes: state,
+                })
+            }
+            ExecutionResult::Revert { output, .. } => Err(revert_handler(output)),
+            ExecutionResult::Halt { reason, .. } => Err(BuilderTransactionError::other(
+                BuilderTransactionError::TransactionHalted(reason),
+            )),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -322,7 +428,3 @@ pub fn get_balance(
         .map(|acc| acc.account_info().unwrap_or_default().balance)
         .map_err(|_| BuilderTransactionError::AccountLoadFailed(address))
 }
-
-pub fn log_exists(logs: &[Log], topic: &B256) -> bool {
-    logs.iter().any(|log| log.topics().first() == Some(topic))
-}

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

@@ -2,7 +2,7 @@ use alloy_consensus::TxEip1559;
 use alloy_eips::Encodable2718;
 use alloy_evm::{Database, Evm};
 use alloy_op_evm::OpEvm;
-use alloy_primitives::{Address, B256, TxKind};
+use alloy_primitives::{Address, TxKind};
 use alloy_sol_types::{Error, SolCall, SolEvent, SolInterface, sol};
 use core::fmt::Debug;
 use op_alloy_consensus::OpTypedTransaction;
@@ -21,7 +21,7 @@ use tracing::warn;
 use crate::{
     builders::{
         BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions,
-        builder_tx::{BuilderTxBase, get_nonce, log_exists},
+        builder_tx::{BuilderTxBase, get_nonce},
         context::OpPayloadBuilderCtx,
         flashblocks::payload::{FlashblocksExecutionInfo, FlashblocksExtraCtx},
     },
@@ -53,8 +53,6 @@ sol!(
 pub(super) enum FlashblockNumberError {
     #[error("flashblocks number contract tx reverted: {0:?}")]
     Revert(IFlashblockNumber::IFlashblockNumberErrors),
-    #[error("contract may be invalid, mismatch in log emitted: expected {0:?}")]
-    LogMismatch(B256),
     #[error("unknown revert: {0} err: {1}")]
     Unknown(String, Error),
     #[error("halt: {0:?}")]
@@ -184,14 +182,15 @@ impl FlashblocksNumberBuilderTx {
 
         match result {
             ExecutionResult::Success { gas_used, logs, .. } => {
-                if log_exists(
-                    &logs,
-                    &IFlashblockNumber::FlashblockIncremented::SIGNATURE_HASH,
-                ) {
+                if logs.iter().any(|log| {
+                    log.topics().first()
+                        == Some(&IFlashblockNumber::FlashblockIncremented::SIGNATURE_HASH)
+                }) {
                     Ok(gas_used)
                 } else {
-                    Err(BuilderTransactionError::other(
-                        FlashblockNumberError::LogMismatch(
+                    Err(BuilderTransactionError::InvalidContract(
+                        self.flashblock_number_address,
+                        crate::builders::InvalidContractDataError::InvalidLogs(
                             IFlashblockNumber::FlashblockIncremented::SIGNATURE_HASH,
                         ),
                     ))
@@ -261,6 +260,7 @@ impl BuilderTransactions<FlashblocksExtraCtx, FlashblocksExecutionInfo>
                     .evm_with_env(simulation_state, ctx.evm_env.clone());
                 evm.modify_cfg(|cfg| {
                     cfg.disable_balance_check = true;
+                    cfg.disable_block_gas_limit = true;
                 });
 
                 let nonce = get_nonce(evm.db_mut(), signer.address)?;

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

@@ -22,8 +22,8 @@ mod generator;
 mod standard;
 
 pub use builder_tx::{
-    BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions, get_balance, get_nonce,
-    log_exists,
+    BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions, InvalidContractDataError,
+    SimulationSuccessResult, get_balance, get_nonce,
 };
 pub use context::OpPayloadBuilderCtx;
 pub use flashblocks::FlashblocksBuilder;