fix(levm): fix execution of eftests

cmd/ef_tests/levm/deserialize.rs

@@ -1,11 +1,77 @@
-use crate::types::EFTest;
+use crate::types::{EFTest, TransactionExpectedException};
 use bytes::Bytes;
-use ethrex_core::U256;
-use serde::Deserialize;
+use ethrex_core::{H256, U256};
+use serde::{Deserialize, Deserializer};
 use std::{collections::HashMap, str::FromStr};
 
 use crate::types::{EFTestRawTransaction, EFTestTransaction};
 
+pub fn deserialize_transaction_expected_exception<'de, D>(
+    deserializer: D,
+) -> Result<Option<Vec<TransactionExpectedException>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let option: Option<String> = Option::deserialize(deserializer)?;
+
+    if let Some(value) = option {
+        let exceptions = value
+            .split('|')
+            .map(|s| match s.trim() {
+                "TransactionException.INITCODE_SIZE_EXCEEDED" => {
+                    TransactionExpectedException::InitcodeSizeExceeded
+                }
+                "TransactionException.NONCE_IS_MAX" => TransactionExpectedException::NonceIsMax,
+                "TransactionException.TYPE_3_TX_BLOB_COUNT_EXCEEDED" => {
+                    TransactionExpectedException::Type3TxBlobCountExceeded
+                }
+                "TransactionException.TYPE_3_TX_ZERO_BLOBS" => {
+                    TransactionExpectedException::Type3TxZeroBlobs
+                }
+                "TransactionException.TYPE_3_TX_CONTRACT_CREATION" => {
+                    TransactionExpectedException::Type3TxContractCreation
+                }
+                "TransactionException.TYPE_3_TX_INVALID_BLOB_VERSIONED_HASH" => {
+                    TransactionExpectedException::Type3TxInvalidBlobVersionedHash
+                }
+                "TransactionException.INTRINSIC_GAS_TOO_LOW" => {
+                    TransactionExpectedException::IntrinsicGasTooLow
+                }
+                "TransactionException.INSUFFICIENT_ACCOUNT_FUNDS" => {
+                    TransactionExpectedException::InsufficientAccountFunds
+                }
+                "TransactionException.SENDER_NOT_EOA" => TransactionExpectedException::SenderNotEoa,
+                "TransactionException.PRIORITY_GREATER_THAN_MAX_FEE_PER_GAS" => {
+                    TransactionExpectedException::PriorityGreaterThanMaxFeePerGas
+                }
+                "TransactionException.GAS_ALLOWANCE_EXCEEDED" => {
+                    TransactionExpectedException::GasAllowanceExceeded
+                }
+                "TransactionException.INSUFFICIENT_MAX_FEE_PER_GAS" => {
+                    TransactionExpectedException::InsufficientMaxFeePerGas
+                }
+                "TransactionException.RLP_INVALID_VALUE" => {
+                    TransactionExpectedException::RlpInvalidValue
+                }
+                "TransactionException.GASLIMIT_PRICE_PRODUCT_OVERFLOW" => {
+                    TransactionExpectedException::GasLimitPriceProductOverflow
+                }
+                "TransactionException.TYPE_3_TX_PRE_FORK" => {
+                    TransactionExpectedException::Type3TxPreFork
+                }
+                "TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS" => {
+                    TransactionExpectedException::InsufficientMaxFeePerBlobGas
+                }
+                other => panic!("Unexpected error type: {}", other), // Should not fail, TODO is to return an error
+            })
+            .collect();
+
+        Ok(Some(exceptions))
+    } else {
+        Ok(None)
+    }
+}
+
 pub fn deserialize_ef_post_value_indexes<'de, D>(
     deserializer: D,
 ) -> Result<HashMap<String, U256>, D::Error>
@@ -52,6 +118,29 @@ where
     Ok(ret)
 }
 
+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_u256_safe<'de, D>(deserializer: D) -> Result<U256, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -165,6 +254,10 @@ impl<'de> Deserialize<'de> for EFTest {
                         sender: raw_tx.sender,
                         to: raw_tx.to.clone(),
                         value: *value,
+                        max_fee_per_gas: raw_tx.max_fee_per_gas,
+                        max_priority_fee_per_gas: raw_tx.max_priority_fee_per_gas,
+                        max_fee_per_blob_gas: raw_tx.max_fee_per_blob_gas,
+                        blob_versioned_hashes: raw_tx.blob_versioned_hashes.clone(),
                     };
                     transactions.push(((data_id, gas_limit_id, value_id), tx));
                 }

cmd/ef_tests/levm/runner.rs

@@ -1,4 +1,8 @@
-use crate::{report::EFTestsReport, types::EFTest, utils};
+use crate::{
+    report::EFTestsReport,
+    types::{EFTest, EFTestPostValue, TransactionExpectedException},
+    utils,
+};
 use ethrex_core::{
     types::{code_hash, AccountInfo},
     H256, U256,
@@ -32,21 +36,29 @@ pub fn run_ef_tests() -> Result<EFTestsReport, Box<dyn Error>> {
             })
         {
             // TODO: Figure out what to do with overflowed value: 0x10000000000000000000000000000000000000000000000000000000000000001.
-            // Deserialization fails because the value is too big for U256.
+            // Deserialization of ValueOverflowParis fails because the value is too big for U256.
+            // Intrinsic is skipped because execution fails as access lists are not yet implemented.
             if test
                 .path()
                 .file_name()
-                .is_some_and(|name| name == "ValueOverflowParis.json")
+                .is_some_and(|name| name == "ValueOverflowParis.json" || name == "intrinsic.json")
             {
                 continue;
             }
+            // 'If' for running a specific test when necessary.
+            // if test
+            //     .path()
+            //     .file_name()
+            //     .is_some_and(|name| name == "valCausesOOF.json")
+            // {
             let test_result = run_ef_test(
                 serde_json::from_reader(std::fs::File::open(test.path())?)?,
                 &mut report,
             );
             if test_result.is_err() {
                 continue;
             }
+            // }
         }
         spinner.update_text(report.progress());
     }
@@ -64,13 +76,18 @@ pub fn run_ef_test_tx(
     let mut evm = prepare_vm_for_tx(tx_id, test)?;
     ensure_pre_state(&evm, test)?;
     let execution_result = evm.transact();
-    ensure_post_state(execution_result, test, report)?;
+    ensure_post_state(execution_result, test, report, tx_id)?;
     Ok(())
 }
 
 pub fn run_ef_test(test: EFTest, report: &mut EFTestsReport) -> Result<(), Box<dyn Error>> {
+    println!("Running test: {}", &test.name);
     let mut failed = false;
     for (tx_id, (tx_indexes, _tx)) in test.transactions.iter().enumerate() {
+        // Code for debugging a specific case.
+        // if *tx_indexes != (346, 0, 0) {
+        //     continue;
+        // }
         match run_ef_test_tx(tx_id, &test, report) {
             Ok(_) => {}
             Err(e) => {
@@ -100,7 +117,7 @@ pub fn prepare_vm_for_tx(tx_id: usize, test: &EFTest) -> Result<VM, Box<dyn Erro
             origin: test.transactions.get(tx_id).unwrap().1.sender,
             consumed_gas: U256::default(),
             refunded_gas: U256::default(),
-            gas_limit: test.env.current_gas_limit,
+            gas_limit: test.transactions.get(tx_id).unwrap().1.gas_limit, // Gas limit of Tx
             block_number: test.env.current_number,
             coinbase: test.env.current_coinbase,
             timestamp: test.env.current_timestamp,
@@ -116,7 +133,22 @@ pub fn prepare_vm_for_tx(tx_id: usize, test: &EFTest) -> Result<VM, Box<dyn Erro
                 .unwrap_or_default(), // or max_fee_per_gas?
             block_excess_blob_gas: Some(test.env.current_excess_blob_gas),
             block_blob_gas_used: None,
-            tx_blob_hashes: None,
+            tx_blob_hashes: test
+                .transactions
+                .get(tx_id)
+                .unwrap()
+                .1
+                .blob_versioned_hashes
+                .clone(),
+            block_gas_limit: test.env.current_gas_limit,
+            tx_max_priority_fee_per_gas: test
+                .transactions
+                .get(tx_id)
+                .unwrap()
+                .1
+                .max_priority_fee_per_gas,
+            tx_max_fee_per_gas: test.transactions.get(tx_id).unwrap().1.max_fee_per_gas,
+            tx_max_fee_per_blob_gas: test.transactions.get(tx_id).unwrap().1.max_fee_per_blob_gas,
         },
         test.transactions.get(tx_id).unwrap().1.value,
         test.transactions.get(tx_id).unwrap().1.data.clone(),
@@ -184,31 +216,121 @@ fn ensure_pre_state_condition(condition: bool, error_reason: String) -> Result<(
     Ok(())
 }
 
+fn get_indexes_tuple(post_value: &EFTestPostValue) -> Option<(usize, usize, usize)> {
+    let data_index: usize = post_value.indexes.get("data")?.as_usize();
+    let gas_index: usize = post_value.indexes.get("gas")?.as_usize();
+    let value_index: usize = post_value.indexes.get("value")?.as_usize();
+    Some((data_index, gas_index, value_index))
+}
+
+fn get_post_value(test: &EFTest, tx_id: usize) -> Option<EFTestPostValue> {
+    if let Some(transaction) = test.transactions.get(tx_id) {
+        let indexes = transaction.0;
+        test.post
+            .clone()
+            .iter()
+            .find(|post_value| {
+                if let Some(post_indexes) = get_indexes_tuple(post_value) {
+                    indexes == post_indexes
+                } else {
+                    false
+                }
+            })
+            .cloned()
+    } else {
+        None
+    }
+}
+
+// Exceptions not covered: RlpInvalidValue and Type3TxPreFork
+fn exception_is_expected(
+    expected_exceptions: Vec<TransactionExpectedException>,
+    returned_error: VMError,
+) -> bool {
+    expected_exceptions.iter().any(|exception| {
+        matches!(
+            (exception, &returned_error),
+            (
+                TransactionExpectedException::IntrinsicGasTooLow,
+                VMError::IntrinsicGasTooLow
+            ) | (
+                TransactionExpectedException::InsufficientAccountFunds,
+                VMError::InsufficientAccountFunds
+            ) | (
+                TransactionExpectedException::PriorityGreaterThanMaxFeePerGas,
+                VMError::PriorityGreaterThanMaxFeePerGas
+            ) | (
+                TransactionExpectedException::GasLimitPriceProductOverflow,
+                VMError::GasLimitPriceProductOverflow
+            ) | (
+                TransactionExpectedException::SenderNotEoa,
+                VMError::SenderNotEOA
+            ) | (
+                TransactionExpectedException::InsufficientMaxFeePerGas,
+                VMError::InsufficientMaxFeePerGas
+            ) | (
+                TransactionExpectedException::NonceIsMax,
+                VMError::NonceIsMax
+            ) | (
+                TransactionExpectedException::GasAllowanceExceeded,
+                VMError::GasAllowanceExceeded
+            ) | (
+                TransactionExpectedException::Type3TxBlobCountExceeded,
+                VMError::Type3TxBlobCountExceeded
+            ) | (
+                TransactionExpectedException::Type3TxZeroBlobs,
+                VMError::Type3TxZeroBlobs
+            ) | (
+                TransactionExpectedException::Type3TxContractCreation,
+                VMError::Type3TxContractCreation
+            ) | (
+                TransactionExpectedException::Type3TxInvalidBlobVersionedHash,
+                VMError::Type3TxInvalidBlobVersionedHash
+            ) | (
+                TransactionExpectedException::InsufficientMaxFeePerBlobGas,
+                VMError::InsufficientMaxFeePerBlobGas
+            ) | (
+                TransactionExpectedException::InitcodeSizeExceeded,
+                VMError::InitcodeSizeExceeded
+            )
+        )
+    })
+}
+
 pub fn ensure_post_state(
     execution_result: Result<TransactionReport, VMError>,
     test: &EFTest,
     report: &mut EFTestsReport,
+    tx_id: usize,
 ) -> Result<(), Box<dyn Error>> {
+    let post_value = get_post_value(test, tx_id);
     match execution_result {
         Ok(execution_report) => {
-            match test
-                .post
-                .clone()
-                .values()
-                .first()
-                .map(|v| v.clone().expect_exception)
-            {
+            match post_value.clone().map(|v| v.clone().expect_exception) {
                 // Execution result was successful but an exception was expected.
-                Some(Some(expected_exception)) => {
-                    let error_reason = format!("Expected exception: {expected_exception}");
+                Some(Some(expected_exceptions)) => {
+                    let error_reason = match expected_exceptions.get(1) {
+                        Some(second_exception) => {
+                            format!(
+                                "Expected exception: {:?} or {:?}",
+                                expected_exceptions.first().unwrap(),
+                                second_exception
+                            )
+                        }
+                        None => {
+                            format!(
+                                "Expected exception: {:?}",
+                                expected_exceptions.first().unwrap()
+                            )
+                        }
+                    };
+
                     return Err(format!("Post-state condition failed: {error_reason}").into());
                 }
                 // Execution result was successful and no exception was expected.
-                // TODO: Check that the post-state matches the expected post-state.
                 None | Some(None) => {
                     let pos_state_root = post_state_root(execution_report, test);
-                    let expected_post_state_value = test.post.iter().next().cloned();
-                    if let Some(expected_post_state_root_hash) = expected_post_state_value {
+                    if let Some(expected_post_state_root_hash) = post_value {
                         let expected_post_state_root_hash = expected_post_state_root_hash.hash;
                         if expected_post_state_root_hash != pos_state_root {
                             let error_reason = format!(
@@ -226,16 +348,31 @@ pub fn ensure_post_state(
             }
         }
         Err(err) => {
-            match test
-                .post
-                .clone()
-                .values()
-                .first()
-                .map(|v| v.clone().expect_exception)
-            {
+            match post_value.map(|v| v.clone().expect_exception) {
                 // Execution result was unsuccessful and an exception was expected.
-                // TODO: Check that the exception matches the expected exception.
-                Some(Some(_expected_exception)) => {}
+                Some(Some(expected_exceptions)) => {
+                    // Instead of cloning could use references
+                    if !exception_is_expected(expected_exceptions.clone(), err.clone()) {
+                        let error_reason = match expected_exceptions.get(1) {
+                            Some(second_exception) => {
+                                format!(
+                                    "Returned exception is not the expected: Returned {:?} but expected {:?} or {:?}",
+                                    err,
+                                    expected_exceptions.first().unwrap(),
+                                    second_exception
+                                )
+                            }
+                            None => {
+                                format!(
+                                    "Returned exception is not the expected: Returned {:?} but expected {:?}",
+                                    err,
+                                    expected_exceptions.first().unwrap()
+                                )
+                            }
+                        };
+                        return Err(format!("Post-state condition failed: {error_reason}").into());
+                    }
+                }
                 // Execution result was unsuccessful but no exception was expected.
                 None | Some(None) => {
                     let error_reason = format!("Unexpected exception: {err:?}");

cmd/ef_tests/levm/tests/test.rs

@@ -1,6 +1,5 @@
 use ef_tests_levm::runner;
 
 fn main() {
-    let report = runner::run_ef_tests().unwrap();
-    println!("{report}");
+    runner::run_ef_tests().unwrap();
 }