fix log validation

Author: avalonche

Cargo.lock

@@ -68,7 +68,7 @@ cargo run -p op-rbuilder --bin op-rbuilder --features=flashtestations -- node \
 - `--flashtestations.enable-block-proofs`: Enable end-of-block transaction proofs that verify the block was built within a TEE
 - `--flashtestations.debug`: Enable debug mode with a deterministic TEE key and debug attestation server for testing and development
 - `--flashtestations.quote-provider <URL>`: Specify a remote URL to provide an attestation instead of generating a quote in process
-- `--flashtestations.rpc-url <URL>`: Use a remote provider to submit attestations to
+- `--flashtestations.rpc-url <URL>`: Use a remote rpc provider to submit attestations to
 
 ## Observability
 

README.md

@@ -59,6 +59,7 @@ alloy-primitives.workspace = true
 alloy-consensus.workspace = true
 alloy-contract.workspace = true
 alloy-eips.workspace = true
+alloy-evm.workspace = true
 alloy-rpc-types-beacon.workspace = true
 alloy-rpc-types-engine.workspace = true
 alloy-transport-http.workspace = true

crates/op-rbuilder/Cargo.toml

@@ -1,5 +1,6 @@
 use alloy_consensus::TxEip1559;
 use alloy_eips::{eip7623::TOTAL_COST_FLOOR_PER_TOKEN, Encodable2718};
+use alloy_evm::Database;
 use alloy_primitives::{
     map::foldhash::{HashSet, HashSetExt},
     Address, TxKind,
@@ -15,7 +16,7 @@ use reth_provider::{ProviderError, StateProvider};
 use reth_revm::State;
 use revm::{
     context::result::{EVMError, ResultAndState},
-    Database, DatabaseCommit,
+    DatabaseCommit,
 };
 use tracing::{debug, warn};
 
@@ -75,15 +76,15 @@ pub trait BuilderTransactions: Debug {
         state_provider: impl StateProvider,
         info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>;
 
     fn add_builder_txs<Extra: Debug + Default>(
         &self,
         state_provider: impl StateProvider,
         info: &mut ExecutionInfo<Extra>,
         builder_ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
     ) -> Result<(), BuilderTransactionError> {
         {
             let mut evm = builder_ctx
@@ -156,7 +157,7 @@ impl StandardBuilderTx {
     pub fn simulate_builder_tx(
         &self,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
     ) -> Result<Option<BuilderTransactionCtx>, BuilderTransactionError> {
         match self.signer {
             Some(signer) => {
@@ -197,17 +198,14 @@ impl StandardBuilderTx {
         std::cmp::max(zero_cost + nonzero_cost + 21_000, floor_gas)
     }
 
-    fn signed_builder_tx<DB>(
+    fn signed_builder_tx(
         &self,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<DB>,
+        db: &mut State<impl Database>,
         signer: Signer,
         gas_used: u64,
         message: Vec<u8>,
-    ) -> Result<Recovered<OpTransactionSigned>, BuilderTransactionError>
-    where
-        DB: Database<Error = ProviderError>,
-    {
+    ) -> Result<Recovered<OpTransactionSigned>, BuilderTransactionError> {
         let nonce = db
             .load_cache_account(signer.address)
             .map(|acc| acc.account_info().unwrap_or_default().nonce)
@@ -240,7 +238,7 @@ impl BuilderTransactions for StandardBuilderTx {
         _state_provider: impl StateProvider,
         _info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
         let builder_tx = self.simulate_builder_tx(ctx, db)?;
         Ok(builder_tx.into_iter().collect())

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

@@ -1,5 +1,6 @@
 use alloy_consensus::{conditional::BlockConditionalAttributes, Eip658Value, Transaction};
 use alloy_eips::Typed2718;
+use alloy_evm::Database;
 use alloy_op_evm::block::receipt_builder::OpReceiptBuilder;
 use alloy_primitives::{BlockHash, Bytes, U256};
 use alloy_rpc_types_eth::Withdrawals;
@@ -27,12 +28,9 @@ use reth_optimism_txpool::{
 use reth_payload_builder::PayloadId;
 use reth_primitives::SealedHeader;
 use reth_primitives_traits::{InMemorySize, SignedTransaction};
-use reth_provider::ProviderError;
 use reth_revm::{context::Block, State};
 use reth_transaction_pool::{BestTransactionsAttributes, PoolTransaction};
-use revm::{
-    context::result::ResultAndState, interpreter::as_u64_saturated, Database, DatabaseCommit,
-};
+use revm::{context::result::ResultAndState, interpreter::as_u64_saturated, DatabaseCommit};
 use std::{sync::Arc, time::Instant};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, info, trace};
@@ -237,13 +235,10 @@ impl OpPayloadBuilderCtx {
     }
 
     /// Executes all sequencer transactions that are included in the payload attributes.
-    pub fn execute_sequencer_transactions<DB, E: Debug + Default>(
+    pub fn execute_sequencer_transactions<E: Debug + Default>(
         &self,
-        db: &mut State<DB>,
-    ) -> Result<ExecutionInfo<E>, PayloadBuilderError>
-    where
-        DB: Database<Error = ProviderError> + std::fmt::Debug,
-    {
+        db: &mut State<impl Database>,
+    ) -> Result<ExecutionInfo<E>, PayloadBuilderError> {
         let mut info = ExecutionInfo::with_capacity(self.attributes().transactions.len());
 
         let mut evm = self.evm_config.evm_with_env(&mut *db, self.evm_env.clone());
@@ -324,17 +319,14 @@ impl OpPayloadBuilderCtx {
     /// Executes the given best transactions and updates the execution info.
     ///
     /// Returns `Ok(Some(())` if the job was cancelled.
-    pub fn execute_best_transactions<DB, E: Debug + Default>(
+    pub fn execute_best_transactions<E: Debug + Default>(
         &self,
         info: &mut ExecutionInfo<E>,
-        db: &mut State<DB>,
+        db: &mut State<impl Database>,
         mut best_txs: impl PayloadTxsBounds,
         block_gas_limit: u64,
         block_da_limit: Option<u64>,
-    ) -> Result<Option<()>, PayloadBuilderError>
-    where
-        DB: Database<Error = ProviderError> + std::fmt::Debug,
-    {
+    ) -> Result<Option<()>, PayloadBuilderError> {
         let execute_txs_start_time = Instant::now();
         let mut num_txs_considered = 0;
         let mut num_txs_simulated = 0;
@@ -343,11 +335,7 @@ impl OpPayloadBuilderCtx {
         let mut num_bundles_reverted = 0;
         let base_fee = self.base_fee();
         let tx_da_limit = self.da_config.max_da_tx_size();
-        let mut evm: alloy_op_evm::OpEvm<
-            &mut State<DB>,
-            revm::inspector::NoOpInspector,
-            reth_evm::precompiles::PrecompilesMap,
-        > = self.evm_config.evm_with_env(&mut *db, self.evm_env.clone());
+        let mut evm = self.evm_config.evm_with_env(&mut *db, self.evm_env.clone());
 
         info!(
             target: "payload_builder",

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

@@ -367,7 +367,7 @@ where
                         flashblock_count = flashblock_count,
                         target_gas = total_gas_per_batch,
                         gas_used = info.cumulative_gas_used,
-                        target_da = total_da_per_batch.unwrap_or(0),
+                        target_da = total_da_per_batch,
                         da_used = info.cumulative_da_bytes_used,
                         "Building flashblock",
                     );

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

@@ -9,6 +9,7 @@ use alloy_consensus::{
     constants::EMPTY_WITHDRAWALS, proofs, BlockBody, Header, EMPTY_OMMER_ROOT_HASH,
 };
 use alloy_eips::{eip7685::EMPTY_REQUESTS_HASH, merge::BEACON_NONCE};
+use alloy_evm::Database;
 use alloy_primitives::U256;
 use reth::payload::PayloadBuilderAttributes;
 use reth_basic_payload_builder::{BuildOutcome, BuildOutcomeKind, MissingPayloadBehaviour};
@@ -22,14 +23,13 @@ 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, ProviderError, StateProvider};
+use reth_provider::{ExecutionOutcome, StateProvider};
 use reth_revm::{
     database::StateProviderDatabase, db::states::bundle_state::BundleRetention, State,
 };
 use reth_transaction_pool::{
     BestTransactions, BestTransactionsAttributes, PoolTransaction, TransactionPool,
 };
-use revm::Database;
 use std::{sync::Arc, time::Instant};
 use tokio_util::sync::CancellationToken;
 use tracing::{error, info, warn};
@@ -300,7 +300,7 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
     pub fn execute<BuilderTx>(
         self,
         state_provider: impl StateProvider,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
         ctx: &OpPayloadBuilderCtx,
         builder_tx: BuilderTx,
     ) -> Result<BuildOutcomeKind<ExecutedPayload>, PayloadBuilderError>
@@ -392,7 +392,7 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
     /// Builds the payload on top of the state.
     pub fn build<BuilderTx>(
         self,
-        state: impl Database<Error = ProviderError>,
+        state: impl Database,
         state_provider: impl StateProvider,
         ctx: OpPayloadBuilderCtx,
         builder_tx: BuilderTx,

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

@@ -1,20 +1,21 @@
 use alloy::sol_types::{SolCall, SolEvent, SolValue};
 use alloy_consensus::TxEip1559;
 use alloy_eips::Encodable2718;
+use alloy_evm::Database;
 use alloy_op_evm::OpEvm;
 use alloy_primitives::{keccak256, map::foldhash::HashMap, Address, Bytes, TxKind, B256, U256};
 use core::fmt::Debug;
 use op_alloy_consensus::OpTypedTransaction;
 use reth_evm::{precompiles::PrecompilesMap, ConfigureEvm, Evm, EvmError};
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::{Log, Recovered};
-use reth_provider::{ProviderError, StateProvider};
+use reth_provider::StateProvider;
 use reth_revm::{database::StateProviderDatabase, State};
 use revm::{
     context::result::{ExecutionResult, ResultAndState},
     inspector::NoOpInspector,
     state::Account,
-    Database, DatabaseCommit,
+    DatabaseCommit,
 };
 use std::sync::{
     atomic::{AtomicBool, Ordering},
@@ -177,6 +178,7 @@ impl FlashtestationsBuilderTx {
 
     /// Computes the block content hash according to the formula:
     /// keccak256(abi.encode(parentHash, blockNumber, timestamp, transactionHashes))
+    /// https://github.com/flashbots/rollup-boost/blob/main/specs/flashtestations.md#block-building-process
     fn compute_block_content_hash(
         transactions: Vec<OpTransactionSigned>,
         parent_hash: B256,
@@ -269,9 +271,9 @@ impl FlashtestationsBuilderTx {
 
     fn check_tee_address_registered_log(&self, logs: Vec<Log>, address: Address) -> bool {
         for log in logs {
-            if log.topics().len() > 1 && log.topics()[0] == TEEServiceRegistered::SIGNATURE_HASH {
+            if log.topics().first() == Some(&TEEServiceRegistered::SIGNATURE_HASH) {
                 if let Ok(decoded) = TEEServiceRegistered::decode_log(&log) {
-                    if decoded.address == address {
+                    if decoded.teeAddress == address {
                         return true;
                     }
                 };
@@ -343,9 +345,7 @@ impl FlashtestationsBuilderTx {
 
     fn check_verify_block_proof_log(&self, logs: Vec<Log>) -> bool {
         for log in logs {
-            if log.topics().len() > 1
-                && log.topics()[0] == BlockBuilderProofVerified::SIGNATURE_HASH
-            {
+            if log.topics().first() == Some(&BlockBuilderProofVerified::SIGNATURE_HASH) {
                 return true;
             }
         }
@@ -515,7 +515,7 @@ impl BuilderTransactions for FlashtestationsBuilderTx {
         state_provider: impl StateProvider,
         info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database<Error = ProviderError>>,
+        db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
         let state = StateProviderDatabase::new(state_provider);
         let mut simulation_state = State::builder()