refactor(revme): serve test bytecode through code_by_hash

Seed statetest and blockchaintest pre-state with the bytecode stored
separately from the account (contracts map keyed by code hash) instead of
inlined in AccountInfo. Execution now has to fetch code through
Database::code_by_hash, the way a node's state provider serves it, so the
fixtures exercise every code-loading path and catch loads that forget to
fetch bytecode.

Post-state code validation in blockchaintest falls back to code_by_hash
when the account carries only a hash, and the debug pre-state keeps the
code inlined for readable output.

Author: rakita

bins/revme/src/cmd/blockchaintest.rs

@@ -337,15 +337,18 @@ fn validate_post_state(
     }
 
     for (address, expected_account) in expected_post_state {
-        // Load account from final state
-        let actual_account = state
-            .load_cache_account(*address)
-            .map_err(|e| TestExecutionError::Database(format!("Account load failed: {e}")))?;
-        let info = actual_account
-            .account
-            .as_ref()
-            .map(|a| a.info.clone())
-            .unwrap_or_default();
+        // Load account from final state. Info and storage are cloned so the borrow
+        // of `state` ends here and it can be queried again below (e.g. for code).
+        let (info, actual_storage) = {
+            let actual_account = state
+                .load_cache_account(*address)
+                .map_err(|e| TestExecutionError::Database(format!("Account load failed: {e}")))?;
+            let account = actual_account.account.as_ref();
+            (
+                account.map(|a| a.info.clone()).unwrap_or_default(),
+                account.map(|a| a.storage.clone()).unwrap_or_default(),
+            )
+        };
 
         // Validate balance
         if info.balance != expected_account.balance {
@@ -376,9 +379,19 @@ fn validate_post_state(
             );
         }
 
-        // Validate code if present
+        // Validate code if present. The account may carry only the code hash when the
+        // code was never loaded during execution, so fall back to `code_by_hash`.
         if !expected_account.code.is_empty() {
-            if let Some(actual_code) = &info.code {
+            let actual_code = match info.code.clone() {
+                Some(code) => Some(code),
+                None if !info.is_empty_code_hash() => {
+                    Some(Database::code_by_hash(state, info.code_hash).map_err(|e| {
+                        TestExecutionError::Database(format!("Code load failed: {e}"))
+                    })?)
+                }
+                None => None,
+            };
+            if let Some(actual_code) = &actual_code {
                 if actual_code.original_bytes() != expected_account.code {
                     return make_failure(
                         state,
@@ -405,23 +418,21 @@ fn validate_post_state(
             }
         }
 
-        // Check for unexpected storage entries. Avoid allocating a temporary HashMap when the account is None.
-        if let Some(acc) = actual_account.account.as_ref() {
-            for (slot, actual_value) in &acc.storage {
-                let slot = *slot;
-                let actual_value = *actual_value;
-                if !expected_account.storage.contains_key(&slot) && !actual_value.is_zero() {
-                    return make_failure(
-                        state,
-                        debug_info,
-                        expected_post_state,
-                        print_env_on_error,
-                        *address,
-                        format!("storage_unexpected[{slot}]"),
-                        "0x0".to_string(),
-                        format!("{actual_value}"),
-                    );
-                }
+        // Check for unexpected storage entries.
+        for (slot, actual_value) in &actual_storage {
+            let slot = *slot;
+            let actual_value = *actual_value;
+            if !expected_account.storage.contains_key(&slot) && !actual_value.is_zero() {
+                return make_failure(
+                    state,
+                    debug_info,
+                    expected_post_state,
+                    print_env_on_error,
+                    *address,
+                    format!("storage_unexpected[{slot}]"),
+                    "0x0".to_string(),
+                    format!("{actual_value}"),
+                );
             }
         }
 
@@ -669,20 +680,38 @@ fn execute_blockchain_test(
     // Capture pre-state for debug info
     let mut pre_state_debug = AddressMap::default();
 
-    // Insert genesis state into database
+    // Insert genesis state into database. Bytecode is stored separately from the
+    // account (in the contracts map, keyed by code hash) so that execution has to
+    // fetch it through `Database::code_by_hash`, like a node's state provider would
+    // serve it.
     let genesis_state = test_case.pre.clone().into_genesis_state();
     for (address, account) in genesis_state {
+        let code_hash = revm::primitives::keccak256(&account.code);
+        let bytecode = (!account.code.is_empty()).then(|| Bytecode::new_raw(account.code.clone()));
         let account_info = AccountInfo {
             balance: account.balance,
             nonce: account.nonce,
-            code_hash: revm::primitives::keccak256(&account.code),
-            code: Some(Bytecode::new_raw(account.code.clone())),
+            code_hash,
+            code: None,
             account_id: None,
         };
 
-        // Store for debug info
+        if let Some(bytecode) = &bytecode {
+            state.cache.contracts.insert(code_hash, bytecode.clone());
+        }
+
+        // Store for debug info, with the code inlined so it shows up in the debug print.
         if print_env_on_error {
-            pre_state_debug.insert(address, (account_info.clone(), account.storage.clone()));
+            pre_state_debug.insert(
+                address,
+                (
+                    AccountInfo {
+                        code: bytecode,
+                        ..account_info.clone()
+                    },
+                    account.storage.clone(),
+                ),
+            );
         }
 
         state.insert_account_with_storage(address, account_info, account.storage);

crates/statetest-types/src/test_unit.rs

@@ -60,19 +60,26 @@ impl TestUnit {
     /// This function uses [`TestUnit::pre`] to prepare the pre-state from the test unit.
     /// It creates a new cache state and inserts the accounts from the test unit.
     ///
+    /// Bytecode is stored separately from the account (in the contracts map, keyed by
+    /// code hash) so that execution has to fetch it through `Database::code_by_hash`,
+    /// like a node's state provider would serve it.
+    ///
     /// # Returns
     ///
-    /// A [`CacheState`] object containing the pre-state accounts and storages.
+    /// A [`CacheState`] object containing the pre-state accounts, storages and contracts.
     pub fn state(&self) -> CacheState {
         let mut cache_state = CacheState::new();
         for (address, info) in &self.pre {
             let code_hash = keccak256(&info.code);
-            let bytecode = Bytecode::new_raw_checked(info.code.clone())
-                .unwrap_or(Bytecode::new_legacy(info.code.clone()));
+            if !info.code.is_empty() {
+                let bytecode = Bytecode::new_raw_checked(info.code.clone())
+                    .unwrap_or(Bytecode::new_legacy(info.code.clone()));
+                cache_state.contracts.insert(code_hash, bytecode);
+            }
             let acc_info = state::AccountInfo {
                 balance: info.balance,
                 code_hash,
-                code: Some(bytecode),
+                code: None,
                 nonce: info.nonce,
                 ..Default::default()
             };