fix: lazy database should be first interface

Author: meyer9

crates/op-rbuilder/src/block_stm/db_adapter.rs

@@ -382,19 +382,13 @@ where
                     did_exist = true;
                 }
                 ReadResult::Value {
-                    value: EvmStateValue::BalanceIncrement(increment),
+                    value: EvmStateValue::BalanceIncrement(_),
                     version,
                 } => {
-                    // BalanceIncrement is a delta that should be added to the base balance.
-                    // We read the base balance and add the increment.
-                    // Track dependency on the increment write for conflict detection.
-                    self.add_to_reads(
-                        balance_key.clone(),
-                        EvmStateValue::BalanceIncrement(increment),
-                        Some(version),
-                    );
-                    base_info.balance = base_info.balance.saturating_add(increment);
-                    did_exist = true;
+                    // Reading a balance increment counts as an aborted read since we can't know all previous increments
+                    return Err(VersionedDbError::ReadAborted {
+                        aborted_txn_idx: version.txn_idx,
+                    });
                 }
                 ReadResult::Value { value, version } => {
                     return Err(VersionedDbError::InvalidValue {

crates/op-rbuilder/src/block_stm/executor.rs

@@ -54,18 +54,21 @@ impl StateWithIncrements {
     pub fn resolve_state<DB: Database>(self, db: &mut DB) -> Result<EvmState, DB::Error> {
         let mut state = self.loaded_state;
         for (addr, delta) in self.pending_balance_increments.iter() {
-            match state.entry(*addr) {
-                Entry::Occupied(mut entry) => {
-                    entry.get_mut().info.balance = entry.get().info.balance.saturating_add(*delta);
-                }
-                Entry::Vacant(entry) => {
-                    let mut account = db.basic(*addr)?.unwrap_or_default();
-                    account.balance = account.balance.saturating_add(*delta);
-                    let mut account: Account = account.into();
-                    account.mark_touch();
-                    entry.insert(account);
-                }
+            let mut account = db.basic(*addr)?.unwrap_or_default();
+            // if loaded_state also has an entry and it doesn't match the account from the database, we have a problem
+            // Addresses in pending_balance_increments must not be in loaded_state
+            if let Some(loaded_account) = state.get(addr) {
+                debug_assert_eq!(
+                    loaded_account.info, account,
+                    "Address {} in pending_balance_increments must not be in loaded_state",
+                    addr
+                );
             }
+
+            account.balance = account.balance.saturating_add(*delta);
+            let mut account: Account = account.into();
+            account.mark_touch();
+            state.insert(*addr, account);
         }
         Ok(state)
     }
@@ -105,7 +108,7 @@ impl<
     pub fn execute_single_tx<
         ExecuteTxFn: (Fn(
                 &Recovered<op_alloy_consensus::OpTxEnvelope>,
-                &mut State<LazyDatabaseWrapper<VersionedDatabase<'_, DB>>>,
+                &mut LazyDatabaseWrapper<State<VersionedDatabase<'_, DB>>>,
                 &HashSet<EvmStateKey>,
                 Option<&TxExecutionResult>,
                 u64,
@@ -140,11 +143,11 @@ impl<
                 Arc::clone(&self.shared_code_cache),
             );
 
-            // Wrap with LazyDatabaseWrapper to track balance increments (fee payments)
-            let lazy_db = LazyDatabaseWrapper::new(versioned_db);
-
             // Create State wrapper for EVM execution
-            let mut tx_state = State::builder().with_database(lazy_db).build();
+            let tx_state = State::builder().with_database(versioned_db).build();
+
+            // Wrap with LazyDatabaseWrapper to track balance increments (fee payments)
+            let mut tx_state = LazyDatabaseWrapper::new(tx_state);
 
             // Detect conflicting keys for re-executions (incarnation > 0)
             // Conflicting keys are reads whose versions changed since the previous execution
@@ -204,10 +207,11 @@ impl<
                     let mut write_set = WriteSet::new();
 
                     // Extract pending balance increments from LazyDatabaseWrapper
-                    let pending_balance_increments = tx_state.database.pending_increments();
+                    // These are balances that were incremented only and never read otherwise.
+                    let pending_balance_increments = tx_state.pending_increments();
 
                     // Get read set and captured reads from inner VersionedDatabase
-                    let versioned_db = tx_state.database.inner_mut();
+                    let versioned_db = &mut tx_state.inner_mut().database;
                     let read_set = versioned_db.take_read_set();
                     let captured_reads = versioned_db.take_captured_reads();
 
@@ -335,7 +339,7 @@ impl<
                         "Read aborted for transaction"
                     );
 
-                    let read_set = tx_state.database.inner_mut().take_read_set();
+                    let read_set = tx_state.inner_mut().database.take_read_set();
                     return (
                         read_set,
                         Default::default(),
@@ -367,7 +371,7 @@ impl<
                         "Error executing transaction"
                     );
 
-                    let read_set = tx_state.database.inner_mut().take_read_set();
+                    let read_set = tx_state.inner_mut().database.take_read_set();
                     return (
                         read_set,
                         Default::default(),
@@ -391,7 +395,7 @@ impl<
     pub fn execute_transactions_parallel<
         ExecuteTxFn: (Fn(
                 &Recovered<op_alloy_consensus::OpTxEnvelope>,
-                &mut State<LazyDatabaseWrapper<VersionedDatabase<'_, DB>>>,
+                &mut LazyDatabaseWrapper<State<VersionedDatabase<'_, DB>>>,
                 &HashSet<EvmStateKey>,
                 Option<&TxExecutionResult>,
                 u64,

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

@@ -959,13 +959,13 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx, OpEvmFactory> {
 
                     // 1. Read BlockResourceUsed increments from other txs BEFORE execution to detect conflicts earlier
                     // These are increments from other transactions within this flashblock (not the base from sequencer)
-                    let gas_increment = state.database.inner_mut()
+                    let gas_increment = state.inner_mut().database
                         .read_block_resource(BlockResourceType::Gas)?;
-                    let da_increment = state.database.inner_mut()
+                    let da_increment = state.inner_mut().database
                         .read_block_resource(BlockResourceType::DABytes)?;
 
                     // Read AddressGasUsed for this address to check rate limiting
-                    let address_gas_used = state.database.inner_mut()
+                    let address_gas_used = state.inner_mut().database
                         .read_address_gas_used(tx.signer())?;
 
                     trace!(
@@ -1103,15 +1103,15 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx, OpEvmFactory> {
                         new_gas_cumulative, new_da_cumulative, new_address_gas_cumulative, gas_increment, tx_gas_used, da_increment, tx_da_size, address_gas_used, tx_gas_used
                     );
 
-                    state.database.inner_mut().write_block_resource(
+                    state.inner_mut().database.write_block_resource(
                         BlockResourceType::Gas,
                         new_gas_cumulative
                     )?;
-                    state.database.inner_mut().write_block_resource(
+                    state.inner_mut().database.write_block_resource(
                         BlockResourceType::DABytes,
                         new_da_cumulative
                     )?;
-                    state.database.inner_mut().write_address_gas_used(
+                    state.inner_mut().database.write_address_gas_used(
                         tx.signer(),
                         new_address_gas_cumulative
                     )?;
@@ -1178,11 +1178,6 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx, OpEvmFactory> {
             for (address, _) in resolved_state.iter() {
                 let _ = db.load_cache_account(*address);
             }
-            for address in pending_balance_addrs {
-                if !resolved_state.contains_key(&address) {
-                    let _ = db.load_cache_account(address);
-                }
-            }
 
             let mut mock_db = MockDB;
             let evm = self