feat(levm): add legacy test to the LEVM EF tests suite

cmd/ef_tests/levm/deserialize.rs

@@ -1,14 +1,13 @@
 use crate::types::{
     EFTest, EFTestAccessListItem, EFTestAuthorizationListTuple, EFTests,
-    TransactionExpectedException,
+    TransactionExpectedException,EFTestPostValue,EFTestTransaction
 };
 use bytes::Bytes;
 use ethrex_core::{H256, U256};
+use ethrex_vm::SpecId;
 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>
@@ -43,7 +42,9 @@ where
                 "TransactionException.INSUFFICIENT_ACCOUNT_FUNDS" => {
                     TransactionExpectedException::InsufficientAccountFunds
                 }
-                "TransactionException.SENDER_NOT_EOA" => TransactionExpectedException::SenderNotEoa,
+                "TransactionException.SENDER_NOT_EOA" | "SenderNotEOA" => {
+                    TransactionExpectedException::SenderNotEoa
+                }
                 "TransactionException.PRIORITY_GREATER_THAN_MAX_FEE_PER_GAS" => {
                     TransactionExpectedException::PriorityGreaterThanMaxFeePerGas
                 }
@@ -68,6 +69,21 @@ where
                 "TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS" => {
                     TransactionExpectedException::InsufficientMaxFeePerBlobGas
                 }
+                "TR_InitCodeLimitExceeded" => TransactionExpectedException::InitCodeLimitExceeded,
+                "TR_NonceHasMaxValue" => TransactionExpectedException::NonceHasMaxValue,
+                "TR_BLOBLIST_OVERSIZE" => TransactionExpectedException::BloblistOversize,
+                "TR_EMPTYBLOB" => TransactionExpectedException::EmptyBlob,
+                "TR_BLOBCREATE" => TransactionExpectedException::BlobCreate,
+                "TR_BLOBVERSION_INVALID" => TransactionExpectedException::BlobVersionInvalid,
+                "TR_TypeNotSupported" => TransactionExpectedException::TypeNotSupported,
+                "TR_IntrinsicGas" | "IntrinsicGas" => TransactionExpectedException::IntrinsicGas,
+                "TR_NoFunds" => TransactionExpectedException::NoFunds,
+                "TR_TipGtFeeCap" => TransactionExpectedException::TipGtFeeCap,
+                "TR_GasLimitReached" => TransactionExpectedException::GasLimitReached,
+                "TR_FeeCapLessThanBlocks" => TransactionExpectedException::FeeCapLessThanBlocks,
+                "TR_NoFundsX" => TransactionExpectedException::NoFundsX,
+                "TR_NoFundsOrGas" => TransactionExpectedException::NoFundsOrGas,
+                "TR_RLP_WRONGVALUE" => TransactionExpectedException::RlpWrongValue,
                 other => panic!("Unexpected error type: {}", other), // Should not fail, TODO is to return an error
             })
             .collect();
@@ -78,6 +94,44 @@ where
     }
 }
 
+pub fn deserialize_legacy_forks<'de, D>(
+    deserializer: D,
+) -> Result<HashMap<SpecId, Vec<EFTestPostValue>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let map: HashMap<String, Vec<EFTestPostValue>> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (fork_name, values) in map {
+        let spec_id = match fork_name.as_str() {
+            "Frontier" => SpecId::FRONTIER,
+            "Homestead" => SpecId::HOMESTEAD,
+            "Constantinople" => SpecId::CONSTANTINOPLE,
+            "ConstantinopleFix" | "Petersburg" => SpecId::CONSTANTINOPLE,
+            "Istanbul" => SpecId::ISTANBUL,
+            "Berlin" => SpecId::BERLIN,
+            "London" => SpecId::LONDON,
+            "Paris" => SpecId::MERGE,
+            "Merge" => SpecId::MERGE,
+            "Shanghai" => SpecId::SHANGHAI,
+            "Cancun" => SpecId::CANCUN,
+            "Prague" => SpecId::PRAGUE,
+            "Byzantium" => SpecId::BYZANTIUM,
+            "EIP158" => SpecId::SPURIOUS_DRAGON,
+            "EIP150" => SpecId::TANGERINE,
+            other => {
+                return Err(serde::de::Error::custom(format!(
+                    "Unknown fork name: {}",
+                    other
+                )))
+            }
+        };
+        result.insert(spec_id, values);
+    }
+    Ok(result)
+}
+
 pub fn deserialize_ef_post_value_indexes<'de, D>(
     deserializer: D,
 ) -> Result<HashMap<String, U256>, D::Error>
@@ -233,11 +287,20 @@ where
     Vec::<String>::deserialize(deserializer)?
         .iter()
         .map(|s| {
-            U256::from_str(s.trim_start_matches("0x:bigint ")).map_err(|err| {
+            let mut s = s.trim_start_matches("0x:bigint ");
+            if s.len() > 64 {
+                s = &s[..64];
+            }
+            U256::from_str(s).map_err(|err| {
                 serde::de::Error::custom(format!(
                     "error parsing U256 when deserializing U256 vector safely: {err}"
                 ))
             })
+            // U256::from_str(s.trim_start_matches("0x:bigint ")).map_err(|err| {
+            //     serde::de::Error::custom(format!(
+            //         "error parsing U256 when deserializing U256 vector safely: {err}"
+            //     ))
+            // })
         })
         .collect()
 }
@@ -309,6 +372,8 @@ impl<'de> Deserialize<'de> for EFTests {
 
             let mut transactions = HashMap::new();
 
+            // Why we do this?
+            // We expect the same for legacy tests?
             // Note that in this order of iteration, in an example tx with 2 datas, 2 gasLimit and 2 values, order would be
             // 111, 112, 121, 122, 211, 212, 221, 222
             for (data_id, data) in raw_tx.data.iter().enumerate() {