Feat(aurora-evm-tests): Add new CLI logic for ttransactions dump and slow tests bench (#108)

* Added new CLI logic for tx dump and slow tests

* Bench fill refactoring

* Fix RawSpec

* Change has_smaller to iterator check

Author: mrLSD

evm-tests/Cargo.toml

@@ -16,7 +16,7 @@ nursery = { level = "deny", priority = -1 }
 
 [dependencies]
 aurora-engine-precompiles = "2.1.0"
-aurora-evm.workspace = true
+aurora-evm = { workspace = true, features = ["with-serde"] }
 bytecount = "0.6"
 clap = { version = "4.5", features = ["cargo"] }
 c-kzg = "1.0"

evm-tests/src/config.rs

@@ -8,6 +8,8 @@ pub struct VerboseOutput {
     pub verbose_failed: bool,
     pub very_verbose: bool,
     pub print_state: bool,
+    pub print_slow: bool,
+    pub dump_transactions: Option<PathBuf>,
 }
 
 #[derive(Default, Debug, Clone)]

evm-tests/src/execution_results.rs

@@ -1,7 +1,10 @@
 use crate::types::Spec;
-use aurora_evm::backend::MemoryAccount;
-use primitive_types::{H160, H256};
+use aurora_evm::backend::{Apply, Basic, MemoryAccount};
+use aurora_evm::executor::stack::Authorization;
+use primitive_types::{H160, H256, U256};
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
+use std::time::Duration;
 
 #[derive(Clone, Debug)]
 pub struct FailedTestDetails {
@@ -18,6 +21,106 @@ pub struct TestExecutionResult {
     pub total: u64,
     pub failed: u64,
     pub failed_tests: Vec<FailedTestDetails>,
+    pub bench: Vec<TestBench>,
+    pub dump_successful_txs: Vec<RawInput>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct RawInput {
+    pub spec: RawSpec,
+    pub caller: H160,
+    pub value: U256,
+    pub data: Vec<u8>,
+    pub gas_limit: u64,
+    pub access_list: Vec<(H160, Vec<H256>)>,
+    pub authorization_list: Vec<Authorization>,
+    pub apply_values: Vec<RawApply>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum RawApply {
+    Modify {
+        address: H160,
+        basic: Basic,
+        code: Option<Vec<u8>>,
+        storage: Vec<(H256, H256)>,
+        reset_storage: bool,
+    },
+    Delete {
+        address: H160,
+    },
+}
+
+impl<I> From<Apply<I>> for RawApply
+where
+    I: IntoIterator<Item = (H256, H256)>,
+{
+    fn from(value: Apply<I>) -> Self {
+        match value {
+            Apply::Modify {
+                address,
+                basic,
+                code,
+                storage,
+                reset_storage,
+            } => Self::Modify {
+                address,
+                basic,
+                code,
+                storage: storage.into_iter().collect(),
+                reset_storage,
+            },
+            Apply::Delete { address } => Self::Delete { address },
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum RawSpec {
+    Frontier,
+    Homestead,
+    TangerineWhistle,
+    SpuriousDragon,
+    Byzantium,
+    Constantinople,
+    Petersburg,
+    Istanbul,
+    Berlin,
+    London,
+    Merge,
+    Shanghai,
+    Cancun,
+    Prague,
+    Osaka,
+}
+
+impl From<Spec> for RawSpec {
+    fn from(spec: Spec) -> Self {
+        match spec {
+            Spec::Frontier => Self::Frontier,
+            Spec::Homestead => Self::Homestead,
+            Spec::Tangerine => Self::TangerineWhistle,
+            Spec::SpuriousDragon => Self::SpuriousDragon,
+            Spec::Byzantium => Self::Byzantium,
+            Spec::Constantinople => Self::Constantinople,
+            Spec::Petersburg => Self::Petersburg,
+            Spec::Istanbul => Self::Istanbul,
+            Spec::Berlin => Self::Berlin,
+            Spec::London => Self::London,
+            Spec::Merge => Self::Merge,
+            Spec::Shanghai => Self::Shanghai,
+            Spec::Cancun => Self::Cancun,
+            Spec::Prague => Self::Prague,
+            Spec::Osaka => Self::Osaka,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TestBench {
+    pub name: String,
+    pub spec: Spec,
+    pub elapsed: Duration,
 }
 
 impl TestExecutionResult {
@@ -28,12 +131,89 @@ impl TestExecutionResult {
             total: 0,
             failed: 0,
             failed_tests: Vec::new(),
+            bench: Vec::new(),
+            dump_successful_txs: Vec::new(),
         }
     }
 
     pub fn merge(&mut self, src: Self) {
         self.failed_tests.extend(src.failed_tests);
         self.total += src.total;
         self.failed += src.failed;
+
+        for bench in src.bench {
+            self.set_benchmark(bench);
+        }
+
+        self.dump_successful_txs.extend(src.dump_successful_txs);
+    }
+
+    pub fn set_benchmark(&mut self, bench: TestBench) {
+        if self.bench.is_empty() {
+            self.bench.push(bench);
+            return;
+        }
+
+        if self.bench.len() < 100 {
+            self.bench.push(bench);
+            return;
+        }
+
+        // If has smaller elapsed than all existing then skip
+        if !self.bench.iter().any(|b| bench.elapsed > b.elapsed) {
+            return;
+        }
+
+        let mut min_idx = 0usize;
+        let mut min_elapsed = self.bench[0].elapsed;
+        for (i, b) in self.bench.iter().enumerate().skip(1) {
+            if b.elapsed < min_elapsed {
+                min_elapsed = b.elapsed;
+                min_idx = i;
+            }
+        }
+
+        if bench.elapsed > min_elapsed {
+            self.bench[min_idx] = bench;
+        }
+    }
+
+    pub fn print_bench(&self) {
+        let mut items = self.bench.clone();
+        items.sort_unstable_by(|a, b| b.elapsed.cmp(&a.elapsed));
+
+        if items.is_empty() {
+            return;
+        }
+
+        let formatted: Vec<(String, String, String)> = items
+            .iter()
+            .map(|b| {
+                let elapsed_str = format!("{:.6}s", b.elapsed.as_secs_f64());
+                let spec_str = format!("{:?}", b.spec);
+                let name_str = b.name.clone();
+                (elapsed_str, spec_str, name_str)
+            })
+            .collect();
+
+        let mut w_elapsed = 0usize;
+        let mut w_spec = 0usize;
+        let mut w_name = 0usize;
+        for (e, s, n) in &formatted {
+            w_elapsed = w_elapsed.max(e.len());
+            w_spec = w_spec.max(s.len());
+            w_name = w_name.max(n.len());
+        }
+
+        let bold_on = "\x1b[1m";
+        let gray_on = "\x1b[90m";
+        let reset = "\x1b[0m";
+
+        for (e, s, n) in formatted {
+            let e_pad = format!("{e:w_elapsed$}");
+            let s_pad = format!("{s:w_spec$}");
+            let n_pad = format!("{n:w_name$}");
+            println!("{bold_on}{e_pad}{reset}  {gray_on}{s_pad}{reset}  {n_pad}",);
+        }
     }
 }

evm-tests/src/main.rs

@@ -82,6 +82,16 @@ fn main() -> Result<(), String> {
                     arg!(-p --print_state "Print state when the test fails")
                         .default_value("false")
                         .action(ArgAction::SetTrue),
+                )
+                .arg(
+                    arg!(--dump_successful_tx <FILE_NAME> "Optional file name to dump all successful transactions")
+                        .required(false)
+                        .value_parser(value_parser!(PathBuf)),
+                )
+                .arg(
+                    arg!(--slow_tests "Print state slow tests")
+                        .default_value("false")
+                        .action(ArgAction::SetTrue),
                 ),
         )
         .get_matches();
@@ -92,6 +102,8 @@ fn main() -> Result<(), String> {
             verbose_failed: matches.get_flag("verbose_failed"),
             very_verbose: false,
             print_state: false,
+            print_slow: false,
+            dump_transactions: None,
         };
         let mut tests_result = TestExecutionResult::new();
         for src_path in matches.get_many::<PathBuf>("PATH").unwrap() {
@@ -122,6 +134,8 @@ fn main() -> Result<(), String> {
             verbose_failed: matches.get_flag("verbose_failed"),
             very_verbose: matches.get_flag("very_verbose"),
             print_state: matches.get_flag("print_state"),
+            print_slow: matches.get_flag("slow_tests"),
+            dump_transactions: matches.get_one::<PathBuf>("dump_successful_tx").cloned(),
         };
         let mut tests_result = TestExecutionResult::new();
         for src_path in matches.get_many::<PathBuf>("PATH").unwrap() {
@@ -150,9 +164,26 @@ fn main() -> Result<(), String> {
         }
         println!("\nTOTAL: {}", tests_result.total);
         println!("FAILED: {}\n", tests_result.failed);
+
         if tests_result.failed != 0 {
             return Err(format!("tests failed: {}", tests_result.failed));
         }
+
+        if verbose_output.print_slow {
+            println!("SLOW TESTS:");
+            tests_result.print_bench();
+        }
+
+        if let Some(dunp_to_file) = verbose_output.dump_transactions {
+            let txs = tests_result.dump_successful_txs;
+            let data = serde_json::to_string(&txs).expect("JSON serialization failed");
+            fs::write(&dunp_to_file, data).expect("Unable to write file");
+            println!(
+                "TEST SUCCESSFUL TRANSACTIONS DUMPED TO: {} [{}]",
+                dunp_to_file.display(),
+                txs.len()
+            );
+        }
     }
     Ok(())
 }