Fix some tests

Author: meyer9

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

@@ -342,11 +342,35 @@ where
             }
         };
 
+        // Get bytecode - check MVHashMap first for newly deployed contracts
+        let code = if code_hash != revm::primitives::KECCAK_EMPTY {
+            // Contract exists - try to get bytecode
+            if let Some(base_code) = &base_info.code {
+                if base_code.len() > 0 {
+                    // Base has the code
+                    Some(base_code.clone())
+                } else {
+                    // Base code is empty, check MVHashMap for newly deployed contracts
+                    self.mv_hashmap
+                        .get_bytecode(code_hash, self.txn_idx)
+                        .map(Bytecode::new_raw)
+                }
+            } else {
+                // No code in base, check MVHashMap for newly deployed contracts
+                self.mv_hashmap
+                    .get_bytecode(code_hash, self.txn_idx)
+                    .map(Bytecode::new_raw)
+            }
+        } else {
+            // No contract (KECCAK_EMPTY means no code)
+            None
+        };
+
         let account_info = AccountInfo {
             balance,
             nonce,
             code_hash,
-            code: base_info.code.clone(),
+            code,
         };
 
         // Cache the result
@@ -404,7 +428,12 @@ where
 
     /// Read contract code by hash.
     fn code_by_hash_ref(&self, code_hash: B256) -> Result<Bytecode, VersionedDbError> {
-        // Code is usually immutable, read directly from base
+        // First check MVHashMap for bytecode deployed by earlier transactions in this block
+        if let Some(bytecode_bytes) = self.mv_hashmap.get_bytecode(code_hash, self.txn_idx) {
+            return Ok(Bytecode::new_raw(bytecode_bytes));
+        }
+
+        // Fall back to base database for pre-existing contracts
         self.base_db
             .code_by_hash_ref(code_hash)
             .map_err(|e| VersionedDbError::BaseDbError(e.to_string()))

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

@@ -13,7 +13,7 @@
 use crate::block_stm::types::{
     EvmStateKey, EvmStateValue, Incarnation, ReadResult, ResolvedBalance, TxnIndex, Version,
 };
-use alloy_primitives::{Address, U256};
+use alloy_primitives::{Address, B256, Bytes, U256};
 use parking_lot::RwLock;
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
@@ -254,6 +254,10 @@ pub struct MVHashMap {
     /// Balance deltas indexed by address.
     /// These are commutative increments that don't conflict with each other.
     balance_deltas: RwLock<HashMap<Address, RwLock<VersionedDeltas>>>,
+    /// Bytecode cache for newly deployed contracts.
+    /// Maps code_hash → (bytecode, txn_idx that deployed it).
+    /// This allows parallel transactions to access code deployed in the same block.
+    bytecode_cache: RwLock<HashMap<B256, (Bytes, TxnIndex)>>,
     /// Number of transactions in the block (reserved for future use).
     #[allow(dead_code)]
     num_txns: usize,
@@ -265,10 +269,35 @@ impl MVHashMap {
         Self {
             data: RwLock::new(HashMap::new()),
             balance_deltas: RwLock::new(HashMap::new()),
+            bytecode_cache: RwLock::new(HashMap::new()),
             num_txns,
         }
     }
 
+    /// Store bytecode for a newly deployed contract.
+    /// This makes the bytecode available to parallel transactions.
+    pub fn store_bytecode(&self, code_hash: B256, bytecode: Bytes, txn_idx: TxnIndex) {
+        // Don't store empty bytecode or the KECCAK_EMPTY hash
+        if bytecode.is_empty() || code_hash == revm::primitives::KECCAK_EMPTY {
+            return;
+        }
+        let mut cache = self.bytecode_cache.write();
+        cache.insert(code_hash, (bytecode, txn_idx));
+    }
+
+    /// Retrieve bytecode by hash, if it was deployed by a transaction before reader_txn_idx.
+    pub fn get_bytecode(&self, code_hash: B256, reader_txn_idx: TxnIndex) -> Option<Bytes> {
+        let cache = self.bytecode_cache.read();
+        cache.get(&code_hash).and_then(|(bytecode, writer_txn_idx)| {
+            // Only return bytecode if it was written by an earlier transaction
+            if *writer_txn_idx < reader_txn_idx {
+                Some(bytecode.clone())
+            } else {
+                None
+            }
+        })
+    }
+
     /// Write a value at the given version.
     #[instrument(level = "trace", skip(self, value), fields(txn_idx, incarnation, key = %key))]
     pub fn write(

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

@@ -275,6 +275,21 @@ pub trait BuilderTransactions<
     ) -> State<StateProviderDatabase<impl StateProvider>> {
         let state = StateProviderDatabase::new(state_provider);
 
+        // Debug: log accounts with code in the cache
+        for (addr, cached) in db.cache.accounts.iter() {
+            if let Some(ref account) = cached.account {
+                let code_len = account.info.code.as_ref().map(|c| c.len()).unwrap_or(0);
+                if code_len > 0 {
+                    tracing::debug!(
+                        target: "builder_tx",
+                        address = ?addr,
+                        code_len = code_len,
+                        "Cache contains account with code"
+                    );
+                }
+            }
+        }
+
         State::builder()
             .with_database(state)
             .with_cached_prestate(db.cache.clone())