feat(levm): running all ef tests with revm and fixing problems

cmd/ef_tests/levm/deserialize.rs

@@ -1,6 +1,6 @@
-use crate::types::{EFTest, EFTests};
+use crate::types::{EFTest, EFTestAccessListItem, EFTests};
 use bytes::Bytes;
-use ethrex_core::U256;
+use ethrex_core::{H256, U256};
 use serde::Deserialize;
 use std::{collections::HashMap, str::FromStr};
 
@@ -65,6 +65,50 @@ where
     )
 }
 
+pub fn deserialize_h256_vec_optional_safe<'de, D>(
+    deserializer: D,
+) -> Result<Option<Vec<H256>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let s = Option::<Vec<String>>::deserialize(deserializer)?;
+    match s {
+        Some(s) => {
+            let mut ret = Vec::new();
+            for s in s {
+                ret.push(H256::from_str(s.trim_start_matches("0x")).map_err(|err| {
+                    serde::de::Error::custom(format!(
+                        "error parsing H256 when deserializing H256 vec optional: {err}"
+                    ))
+                })?);
+            }
+            Ok(Some(ret))
+        }
+        None => Ok(None),
+    }
+}
+
+pub fn deserialize_access_lists<'de, D>(
+    deserializer: D,
+) -> Result<Option<Vec<Vec<EFTestAccessListItem>>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let access_lists: Option<Vec<Option<Vec<EFTestAccessListItem>>>> =
+        Option::<Vec<Option<Vec<EFTestAccessListItem>>>>::deserialize(deserializer)?;
+
+    let mut final_access_lists: Vec<Vec<EFTestAccessListItem>> = Vec::new();
+
+    if let Some(access_lists) = access_lists {
+        for access_list in access_lists {
+            // Treat `null` as an empty vector
+            final_access_lists.push(access_list.unwrap_or_default());
+        }
+    }
+
+    Ok(Some(final_access_lists))
+}
+
 pub fn deserialize_u256_optional_safe<'de, D>(deserializer: D) -> Result<Option<U256>, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -164,6 +208,20 @@ impl<'de> Deserialize<'de> for EFTests {
                             sender: raw_tx.sender,
                             to: raw_tx.to.clone(),
                             value: *value,
+                            blob_versioned_hashes: raw_tx
+                                .blob_versioned_hashes
+                                .clone()
+                                .unwrap_or_default(),
+                            max_fee_per_blob_gas: raw_tx.max_fee_per_blob_gas,
+                            max_priority_fee_per_gas: raw_tx.max_priority_fee_per_gas,
+                            max_fee_per_gas: raw_tx.max_fee_per_gas,
+                            access_list: raw_tx
+                                .access_lists
+                                .clone()
+                                .unwrap_or_default()
+                                .get(data_id)
+                                .cloned()
+                                .unwrap_or_default(),
                         };
                         transactions.insert((data_id, gas_limit_id, value_id), tx);
                     }

cmd/ef_tests/levm/runner/levm_runner.rs

@@ -78,7 +78,7 @@ pub fn prepare_vm_for_tx(vector: &TestVector, test: &EFTest) -> Result<VM, EFTes
             origin: test.transactions.get(vector).unwrap().sender,
             consumed_gas: U256::default(),
             refunded_gas: U256::default(),
-            gas_limit: test.env.current_gas_limit,
+            gas_limit: test.env.current_gas_limit, //this should be tx gas limit
             block_number: test.env.current_number,
             coinbase: test.env.current_coinbase,
             timestamp: test.env.current_timestamp,

cmd/ef_tests/levm/runner/mod.rs

@@ -55,6 +55,7 @@ pub fn run_ef_tests(
         run_with_levm(&mut reports, &ef_tests)?;
     }
     re_run_with_revm(&mut reports, &ef_tests)?;
+    // _run_with_revm(&mut reports, &ef_tests)?;
     write_report(&reports)
 }
 
@@ -88,6 +89,43 @@ fn run_with_levm(
     Ok(())
 }
 
+fn _run_with_revm(
+    reports: &mut Vec<EFTestReport>,
+    ef_tests: &[EFTest],
+) -> Result<(), EFTestRunnerError> {
+    let revm_run_time = std::time::Instant::now();
+    let mut revm_run_spinner = Spinner::new(
+        Dots,
+        "Running all tests with REVM...".to_owned(),
+        Color::Cyan,
+    );
+    for (idx, test) in ef_tests.iter().enumerate() {
+        let total_tests = ef_tests.len();
+        revm_run_spinner.update_text(format!(
+            "{} {}/{total_tests} - {}",
+            "Running all tests with REVM".bold(),
+            idx + 1,
+            format_duration_as_mm_ss(revm_run_time.elapsed())
+        ));
+        let ef_test_report = match revm_runner::_run_ef_test_revm(test) {
+            Ok(ef_test_report) => ef_test_report,
+            Err(EFTestRunnerError::Internal(err)) => return Err(EFTestRunnerError::Internal(err)),
+            non_internal_errors => {
+                return Err(EFTestRunnerError::Internal(InternalError::FirstRunInternal(format!(
+                    "Non-internal error raised when executing revm. This should not happen: {non_internal_errors:?}",
+                ))))
+            }
+        };
+        reports.push(ef_test_report);
+        revm_run_spinner.update_text(report::progress(reports, revm_run_time.elapsed()));
+    }
+    revm_run_spinner.success(&format!(
+        "Ran all tests with REVM in {}",
+        format_duration_as_mm_ss(revm_run_time.elapsed())
+    ));
+    Ok(())
+}
+
 fn re_run_with_revm(
     reports: &mut [EFTestReport],
     ef_tests: &[EFTest],