Add a cached fs abstraction

* Implement various needed features and improvements

* Reorder the metadata struct

* Format comments

Cargo.lock

@@ -4081,6 +4081,7 @@ dependencies = [
  "revive-dt-node-interaction",
  "revive-dt-report",
  "semver 1.0.26",
+ "serde_json",
  "temp-dir",
  "tokio",
  "tracing",
@@ -4095,6 +4096,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
  "anyhow",
+ "revive-common",
  "revive-dt-common",
  "semver 1.0.26",
  "serde",
@@ -4109,6 +4111,7 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
+ "revive-common",
  "revive-dt-common",
  "revive-dt-config",
  "revive-dt-format",

Cargo.toml

@@ -8,7 +8,7 @@ authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT/Apache-2.0"
 edition = "2024"
 repository = "https://github.com/paritytech/revive-differential-testing.git"
-rust-version = "1.85.0"
+rust-version = "1.87.0"
 
 [workspace.dependencies]
 revive-dt-common = { version = "0.1.0", path = "crates/common" }
@@ -36,6 +36,7 @@ serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0", default-features = false, features = [
     "arbitrary_precision",
     "std",
+    "unbounded_depth",
 ] }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"

assets/test_metadata.json

@@ -8,6 +8,18 @@
         {
             "name": "first",
             "inputs": [
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "expected_balance": "1233"
+                },
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "is_storage_empty": true
+                },
+                {
+                    "address": "0xdeadbeef00000000000000000000000000000042",
+                    "is_storage_empty": false
+                },
                 {
                     "instance": "WBTC_1",
                     "method": "#deployer",

crates/common/src/fs/cached_file_system.rs

@@ -0,0 +1,38 @@
+//! Implements a cached file system that allows for files to be read once into memory and then when
+//! they're requested to be read again they will be returned from the cache.
+
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::{Arc, LazyLock},
+};
+
+use anyhow::Result;
+use tokio::sync::RwLock;
+
+#[allow(clippy::type_complexity)]
+static CACHE: LazyLock<Arc<RwLock<HashMap<PathBuf, Vec<u8>>>>> = LazyLock::new(Default::default);
+
+pub struct CachedFileSystem;
+
+impl CachedFileSystem {
+    pub async fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+        let cache_read_lock = CACHE.read().await;
+        match cache_read_lock.get(path.as_ref()) {
+            Some(entry) => Ok(entry.clone()),
+            None => {
+                drop(cache_read_lock);
+
+                let content = std::fs::read(&path)?;
+                let mut cache_write_lock = CACHE.write().await;
+                cache_write_lock.insert(path.as_ref().to_path_buf(), content.clone());
+                Ok(content)
+            }
+        }
+    }
+
+    pub async fn read_to_string(path: impl AsRef<Path>) -> Result<String> {
+        let content = Self::read(path).await?;
+        String::from_utf8(content).map_err(Into::into)
+    }
+}

crates/common/src/fs/mod.rs

@@ -1,3 +1,5 @@
+mod cached_file_system;
 mod clear_dir;
 
+pub use cached_file_system::*;
 pub use clear_dir::*;

crates/common/src/iterators/files_with_extension_iterator.rs

@@ -1,4 +1,8 @@
-use std::{borrow::Cow, collections::HashSet, path::PathBuf};
+use std::{
+    borrow::Cow,
+    collections::HashSet,
+    path::{Path, PathBuf},
+};
 
 /// An iterator that finds files of a certain extension in the provided directory. You can think of
 /// this a glob pattern similar to: `${path}/**/*.md`
@@ -18,10 +22,10 @@ pub struct FilesWithExtensionIterator {
 }
 
 impl FilesWithExtensionIterator {
-    pub fn new(root_directory: PathBuf) -> Self {
+    pub fn new(root_directory: impl AsRef<Path>) -> Self {
         Self {
             allowed_extensions: Default::default(),
-            directories_to_search: vec![root_directory],
+            directories_to_search: vec![root_directory.as_ref().to_path_buf()],
             files_matching_allowed_extensions: Default::default(),
         }
     }

crates/compiler/src/lib.rs

@@ -5,7 +5,6 @@
 
 use std::{
     collections::HashMap,
-    fs::read_to_string,
     hash::Hash,
     path::{Path, PathBuf},
 };
@@ -16,7 +15,7 @@ use semver::Version;
 use serde::{Deserialize, Serialize};
 
 use revive_common::EVMVersion;
-use revive_dt_common::types::VersionOrRequirement;
+use revive_dt_common::{fs::CachedFileSystem, types::VersionOrRequirement};
 use revive_dt_config::Arguments;
 
 pub mod revive_js;
@@ -55,6 +54,7 @@ pub struct CompilerInput {
     pub base_path: Option<PathBuf>,
     pub sources: HashMap<PathBuf, String>,
     pub libraries: HashMap<PathBuf, HashMap<String, Address>>,
+    pub revert_string_handling: Option<RevertString>,
 }
 
 /// The generic compilation output configuration.
@@ -91,6 +91,7 @@ where
                 base_path: Default::default(),
                 sources: Default::default(),
                 libraries: Default::default(),
+                revert_string_handling: Default::default(),
             },
             additional_options: T::Options::default(),
         }
@@ -121,10 +122,11 @@ where
         self
     }
 
-    pub fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
+    pub async fn with_source(mut self, path: impl AsRef<Path>) -> anyhow::Result<Self> {
-        self.input
+        self.input.sources.insert(
-            .sources
+            path.as_ref().to_path_buf(),
-            .insert(path.as_ref().to_path_buf(), read_to_string(path.as_ref())?);
+            CachedFileSystem::read_to_string(path.as_ref()).await?,
+        );
         Ok(self)
     }
 
@@ -142,6 +144,14 @@ where
         self
     }
 
+    pub fn with_revert_string_handling(
+        mut self,
+        revert_string_handling: impl Into<Option<RevertString>>,
+    ) -> Self {
+        self.input.revert_string_handling = revert_string_handling.into();
+        self
+    }
+
     pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
         self.additional_options = options.into();
         self
@@ -160,3 +170,15 @@ where
         self.input.clone()
     }
 }
+
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+pub enum RevertString {
+    #[default]
+    Default,
+    Debug,
+    Strip,
+    VerboseDebug,
+}

crates/compiler/src/revive_resolc.rs

@@ -47,6 +47,9 @@ impl SolidityCompiler for Resolc {
             base_path,
             sources,
             libraries,
+            // TODO: this is currently not being handled since there is no way to pass it into
+            // resolc. So, we need to go back to this later once it's supported.
+            revert_string_handling: _,
         }: CompilerInput,
         additional_options: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {

crates/compiler/src/solc.rs

@@ -42,6 +42,7 @@ impl SolidityCompiler for Solc {
             base_path,
             sources,
             libraries,
+            revert_string_handling,
         }: CompilerInput,
         _: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
@@ -87,6 +88,15 @@ impl SolidityCompiler for Solc {
                         })
                         .collect(),
                 },
+                debug: revert_string_handling.map(|revert_string_handling| DebuggingSettings {
+                    revert_strings: match revert_string_handling {
+                        crate::RevertString::Default => Some(RevertStrings::Default),
+                        crate::RevertString::Debug => Some(RevertStrings::Debug),
+                        crate::RevertString::Strip => Some(RevertStrings::Strip),
+                        crate::RevertString::VerboseDebug => Some(RevertStrings::VerboseDebug),
+                    },
+                    debug_info: Default::default(),
+                }),
                 ..Default::default()
             },
         };

crates/config/src/lib.rs

@@ -96,10 +96,19 @@ pub struct Arguments {
     #[arg(long, default_value = "1")]
     pub number_of_nodes: usize,
 
-    /// Determines the amount of threads that will will be used.
+    /// Determines the amount of tokio worker threads that will will be used.
-    #[arg(long, default_value = "12")]
+    #[arg(
+        long,
+        default_value_t = std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(1)
+    )]
     pub number_of_threads: usize,
 
+    /// Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes.
+    #[arg(long)]
+    pub number_concurrent_tasks: Option<usize>,
+
     /// Extract problems back to the test corpus.
     #[arg(short, long = "extract-problems")]
     pub extract_problems: bool,
@@ -134,6 +143,13 @@ impl Arguments {
         panic!("should have a workdir configured")
     }
 
+    /// Return the number of concurrent tasks to run. This is provided via the
+    /// `--number-concurrent-tasks` argument, and otherwise defaults to --number-of-nodes * 20.
+    pub fn number_of_concurrent_tasks(&self) -> usize {
+        self.number_concurrent_tasks
+            .unwrap_or(20 * self.number_of_nodes)
+    }
+
     /// Try to parse `self.account` into a [PrivateKeySigner],
     /// panicing on error.
     pub fn wallet(&self) -> EthereumWallet {

crates/core/Cargo.toml

@@ -30,4 +30,5 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
+serde_json = { workspace = true }
 temp-dir = { workspace = true }

crates/core/src/driver/mod.rs

@@ -4,14 +4,15 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
+use alloy::consensus::EMPTY_ROOT_HASH;
 use alloy::hex;
 use alloy::json_abi::JsonAbi;
 use alloy::network::{Ethereum, TransactionBuilder};
 use alloy::primitives::U256;
 use alloy::rpc::types::TransactionReceipt;
 use alloy::rpc::types::trace::geth::{
-    CallFrame, GethDebugBuiltInTracerType, GethDebugTracerType, GethDebugTracingOptions, GethTrace,
+    CallFrame, GethDebugBuiltInTracerType, GethDebugTracerConfig, GethDebugTracerType,
-    PreStateConfig,
+    GethDebugTracingOptions, GethTrace, PreStateConfig,
 };
 use alloy::{
     primitives::Address,
@@ -26,9 +27,12 @@ use revive_dt_format::traits::{ResolutionContext, ResolverApi};
 use semver::Version;
 
 use revive_dt_format::case::{Case, CaseIdx};
-use revive_dt_format::input::{Calldata, EtherValue, Expected, ExpectedOutput, Method};
+use revive_dt_format::input::{
+    BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
+    StorageEmptyAssertion,
+};
 use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
-use revive_dt_format::{input::Input, metadata::Metadata};
+use revive_dt_format::{input::Step, metadata::Metadata};
 use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
 use tracing::Instrument;
@@ -70,6 +74,32 @@ where
         }
     }
 
+    pub async fn handle_step(
+        &mut self,
+        metadata: &Metadata,
+        case_idx: CaseIdx,
+        step: &Step,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<StepOutput> {
+        match step {
+            Step::FunctionCall(input) => {
+                let (receipt, geth_trace, diff_mode) =
+                    self.handle_input(metadata, case_idx, input, node).await?;
+                Ok(StepOutput::FunctionCall(receipt, geth_trace, diff_mode))
+            }
+            Step::BalanceAssertion(balance_assertion) => {
+                self.handle_balance_assertion(metadata, case_idx, balance_assertion, node)
+                    .await?;
+                Ok(StepOutput::BalanceAssertion)
+            }
+            Step::StorageEmptyAssertion(storage_empty) => {
+                self.handle_storage_empty(metadata, case_idx, storage_empty, node)
+                    .await?;
+                Ok(StepOutput::StorageEmptyAssertion)
+            }
+        }
+    }
+
     pub async fn handle_input(
         &mut self,
         metadata: &Metadata,
@@ -78,7 +108,7 @@ where
         node: &T::Blockchain,
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
         let deployment_receipts = self
-            .handle_contract_deployment(metadata, case_idx, input, node)
+            .handle_input_contract_deployment(metadata, case_idx, input, node)
             .await?;
         let execution_receipt = self
             .handle_input_execution(input, deployment_receipts, node)
@@ -93,8 +123,36 @@ where
             .await
     }
 
+    pub async fn handle_balance_assertion(
+        &mut self,
+        metadata: &Metadata,
+        _: CaseIdx,
+        balance_assertion: &BalanceAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        self.handle_balance_assertion_contract_deployment(metadata, balance_assertion, node)
+            .await?;
+        self.handle_balance_assertion_execution(balance_assertion, node)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn handle_storage_empty(
+        &mut self,
+        metadata: &Metadata,
+        _: CaseIdx,
+        storage_empty: &StorageEmptyAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        self.handle_storage_empty_assertion_contract_deployment(metadata, storage_empty, node)
+            .await?;
+        self.handle_storage_empty_assertion_execution(storage_empty, node)
+            .await?;
+        Ok(())
+    }
+
     /// Handles the contract deployment for a given input performing it if it needs to be performed.
-    async fn handle_contract_deployment(
+    async fn handle_input_contract_deployment(
         &mut self,
         metadata: &Metadata,
         case_idx: CaseIdx,
@@ -205,6 +263,11 @@ where
                 tracer: Some(GethDebugTracerType::BuiltInTracer(
                     GethDebugBuiltInTracerType::CallTracer,
                 )),
+                tracer_config: GethDebugTracerConfig(serde_json::json! {{
+                    "onlyTopCall": true,
+                    "withLog": false,
+                    "withReturnData": false
+                }}),
                 ..Default::default()
             },
         )
@@ -462,6 +525,128 @@ where
         Ok((execution_receipt, trace, diff))
     }
 
+    pub async fn handle_balance_assertion_contract_deployment(
+        &mut self,
+        metadata: &Metadata,
+        balance_assertion: &BalanceAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        let Some(instance) = balance_assertion
+            .address
+            .strip_suffix(".address")
+            .map(ContractInstance::new)
+        else {
+            return Ok(());
+        };
+        self.get_or_deploy_contract_instance(
+            &instance,
+            metadata,
+            Input::default_caller(),
+            None,
+            None,
+            node,
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub async fn handle_balance_assertion_execution(
+        &mut self,
+        BalanceAssertion {
+            address: address_string,
+            expected_balance: amount,
+            ..
+        }: &BalanceAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        let address = Address::from_slice(
+            Calldata::new_compound([address_string])
+                .calldata(node, self.default_resolution_context())
+                .await?
+                .get(12..32)
+                .expect("Can't fail"),
+        );
+
+        let balance = node.balance_of(address).await?;
+
+        let expected = *amount;
+        let actual = balance;
+        if expected != actual {
+            tracing::error!(%expected, %actual, %address, "Balance assertion failed");
+            anyhow::bail!(
+                "Balance assertion failed - Expected {} but got {} for {} resolved to {}",
+                expected,
+                actual,
+                address_string,
+                address,
+            )
+        }
+
+        Ok(())
+    }
+
+    pub async fn handle_storage_empty_assertion_contract_deployment(
+        &mut self,
+        metadata: &Metadata,
+        storage_empty_assertion: &StorageEmptyAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        let Some(instance) = storage_empty_assertion
+            .address
+            .strip_suffix(".address")
+            .map(ContractInstance::new)
+        else {
+            return Ok(());
+        };
+        self.get_or_deploy_contract_instance(
+            &instance,
+            metadata,
+            Input::default_caller(),
+            None,
+            None,
+            node,
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub async fn handle_storage_empty_assertion_execution(
+        &mut self,
+        StorageEmptyAssertion {
+            address: address_string,
+            is_storage_empty,
+            ..
+        }: &StorageEmptyAssertion,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        let address = Address::from_slice(
+            Calldata::new_compound([address_string])
+                .calldata(node, self.default_resolution_context())
+                .await?
+                .get(12..32)
+                .expect("Can't fail"),
+        );
+
+        let storage = node.latest_state_proof(address, Default::default()).await?;
+        let is_empty = storage.storage_hash == EMPTY_ROOT_HASH;
+
+        let expected = is_storage_empty;
+        let actual = is_empty;
+
+        if *expected != actual {
+            tracing::error!(%expected, %actual, %address, "Storage Empty Assertion failed");
+            anyhow::bail!(
+                "Storage Empty Assertion failed - Expected {} but got {} for {} resolved to {}",
+                expected,
+                actual,
+                address_string,
+                address,
+            )
+        };
+
+        Ok(())
+    }
+
     /// Gets the information of a deployed contract or library from the state. If it's found to not
     /// be deployed then it will be deployed.
     ///
@@ -651,21 +836,25 @@ where
             return Ok(0);
         }
 
-        let mut inputs_executed = 0;
+        let mut steps_executed = 0;
-        for (input_idx, input) in self.case.inputs_iterator().enumerate() {
+        for (step_idx, step) in self.case.steps_iterator().enumerate() {
-            let tracing_span = tracing::info_span!("Handling input", input_idx);
+            let tracing_span = tracing::info_span!("Handling input", step_idx);
 
-            let (leader_receipt, _, leader_diff) = self
+            let leader_step_output = self
                 .leader_state
-                .handle_input(self.metadata, self.case_idx, &input, self.leader_node)
+                .handle_step(self.metadata, self.case_idx, &step, self.leader_node)
                 .instrument(tracing_span.clone())
                 .await?;
-            let (follower_receipt, _, follower_diff) = self
+            let follower_step_output = self
                 .follower_state
-                .handle_input(self.metadata, self.case_idx, &input, self.follower_node)
+                .handle_step(self.metadata, self.case_idx, &step, self.follower_node)
                 .instrument(tracing_span)
                 .await?;
-
+            match (leader_step_output, follower_step_output) {
+                (
+                    StepOutput::FunctionCall(leader_receipt, _, leader_diff),
+                    StepOutput::FunctionCall(follower_receipt, _, follower_diff),
+                ) => {
                     if leader_diff == follower_diff {
                         tracing::debug!("State diffs match between leader and follower.");
                     } else {
@@ -679,10 +868,23 @@ where
                         tracing::trace!("Leader logs: {:?}", leader_receipt.logs());
                         tracing::trace!("Follower logs: {:?}", follower_receipt.logs());
                     }
-
+                }
-            inputs_executed += 1;
+                (StepOutput::BalanceAssertion, StepOutput::BalanceAssertion) => {}
+                (StepOutput::StorageEmptyAssertion, StepOutput::StorageEmptyAssertion) => {}
+                _ => unreachable!("The two step outputs can not be of a different kind"),
             }
 
-        Ok(inputs_executed)
+            steps_executed += 1;
+        }
+
+        Ok(steps_executed)
     }
 }
+
+#[derive(Clone, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum StepOutput {
+    FunctionCall(TransactionReceipt, GethTrace, DiffMode),
+    BalanceAssertion,
+    StorageEmptyAssertion,
+}

crates/core/src/main.rs

@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    path::Path,
+    path::{Path, PathBuf},
     sync::{Arc, LazyLock},
     time::Instant,
 };
@@ -18,7 +18,7 @@ use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_node_interaction::EthereumNode;
 use semver::Version;
 use temp_dir::TempDir;
-use tokio::sync::{Mutex, RwLock};
+use tokio::sync::{Mutex, RwLock, mpsc};
 use tracing::{Instrument, Level};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
@@ -32,7 +32,7 @@ use revive_dt_core::{
 use revive_dt_format::{
     case::{Case, CaseIdx},
     corpus::Corpus,
-    input::Input,
+    input::{Input, Step},
     metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
     mode::SolcMode,
 };
@@ -41,20 +41,33 @@ use revive_dt_report::reporter::{Report, Span};
 
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
-type CompilationCache<'a> = Arc<
+type CompilationCache = Arc<
     RwLock<
         HashMap<
-            (&'a Path, SolcMode, TestingPlatform),
+            (PathBuf, SolcMode, TestingPlatform),
             Arc<Mutex<Option<Arc<(Version, CompilerOutput)>>>>,
         >,
     >,
 >;
 
+/// this represents a single "test"; a mode, path and collection of cases.
+#[derive(Clone)]
+struct Test {
+    metadata: Metadata,
+    path: PathBuf,
+    mode: SolcMode,
+    case_idx: usize,
+    case: Case,
+}
+
+/// This represents the results that we gather from running test cases.
+type CaseResult = Result<usize, anyhow::Error>;
+
 fn main() -> anyhow::Result<()> {
     let args = init_cli()?;
 
     let body = async {
-        for (corpus, tests) in collect_corpora(&args)? {
+        for (corpus, tests) in collect_corpora(&args).await? {
             let span = Span::new(corpus, args.clone())?;
             match &args.compile_only {
                 Some(platform) => compile_corpus(&args, &tests, platform, span).await,
@@ -104,13 +117,13 @@ fn init_cli() -> anyhow::Result<Arguments> {
     Ok(args)
 }
 
-fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<MetadataFile>>> {
+async fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<MetadataFile>>> {
     let mut corpora = HashMap::new();
 
     for path in &args.corpus {
         let corpus = Corpus::try_from_path(path)?;
         tracing::info!("found corpus: {}", path.display());
-        let tests = corpus.enumerate_tests();
+        let tests = corpus.enumerate_tests().await;
         tracing::info!("corpus '{}' contains {} tests", &corpus.name, tests.len());
         corpora.insert(corpus, tests);
     }
@@ -120,7 +133,7 @@ fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<Metad
 
 async fn run_driver<L, F>(
     args: &Arguments,
-    tests: &[MetadataFile],
+    metadata_files: &[MetadataFile],
     span: Span,
 ) -> anyhow::Result<()>
 where
@@ -129,10 +142,25 @@ where
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_nodes = NodePool::<L::Blockchain>::new(args)?;
+    let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();
-    let follower_nodes = NodePool::<F::Blockchain>::new(args)?;
 
-    let test_cases = tests
+    let tests = prepare_tests::<L, F>(metadata_files);
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx).await?;
+    let status_reporter_task = start_reporter_task(report_rx);
+
+    tokio::join!(status_reporter_task, driver_task);
+
+    Ok(())
+}
+
+fn prepare_tests<L, F>(metadata_files: &[MetadataFile]) -> impl Iterator<Item = Test>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    metadata_files
         .iter()
         .flat_map(
             |MetadataFile {
@@ -177,188 +205,180 @@ where
                 Some(false) | None => true,
             },
         )
-        .collect::<Vec<_>>();
+        .filter(|(metadata_file_path, metadata, ..)| match metadata.required_evm_version {
+            Some(evm_version_requirement) => {
+                let is_allowed = evm_version_requirement
+                    .matches(&<L::Blockchain as revive_dt_node::Node>::evm_version())
+                    && evm_version_requirement
+                        .matches(&<F::Blockchain as revive_dt_node::Node>::evm_version());
 
-    let metadata_case_status = Arc::new(RwLock::new(test_cases.iter().fold(
+                if !is_allowed {
-        HashMap::<_, HashMap<_, _>>::new(),
+                    tracing::warn!(
-        |mut map, (path, _, case_idx, case, solc_mode)| {
+                        metadata_file_path = %metadata_file_path.display(),
-            map.entry((path.to_path_buf(), solc_mode.clone()))
+                        leader_evm_version = %<L::Blockchain as revive_dt_node::Node>::evm_version(),
-                .or_default()
+                        follower_evm_version = %<F::Blockchain as revive_dt_node::Node>::evm_version(),
-                .insert((CaseIdx::new(*case_idx), case.name.clone()), None::<bool>);
+                        version_requirement = %evm_version_requirement,
-            map
+                        "Skipped test since the EVM version requirement was not fulfilled."
-        },
-    )));
-    let status_reporter_task = {
-        let metadata_case_status = metadata_case_status.clone();
-        let start = Instant::now();
-        async move {
-            const GREEN: &str = "\x1B[32m";
-            const RED: &str = "\x1B[31m";
-            const RESET: &str = "\x1B[0m";
-
-            let mut entries_to_delete = Vec::new();
-            let mut number_of_successes = 0;
-            let mut number_of_failures = 0;
-            loop {
-                let metadata_case_status_read = metadata_case_status.read().await;
-                if metadata_case_status_read.is_empty() {
-                    break;
-                }
-
-                for ((metadata_file_path, solc_mode), case_status) in
-                    metadata_case_status_read.iter()
-                {
-                    if case_status.values().any(|value| value.is_none()) {
-                        continue;
-                    }
-
-                    let contains_failures = case_status
-                        .values()
-                        .any(|value| value.is_some_and(|value| !value));
-
-                    if !contains_failures {
-                        eprintln!(
-                            "{}Succeeded:{} {} - {:?}",
-                            GREEN,
-                            RESET,
-                            metadata_file_path.display(),
-                            solc_mode
-                        )
-                    } else {
-                        eprintln!(
-                            "{}Failed:{} {} - {:?}",
-                            RED,
-                            RESET,
-                            metadata_file_path.display(),
-                            solc_mode
-                        )
-                    };
-
-                    number_of_successes += case_status
-                        .values()
-                        .filter(|value| value.is_some_and(|value| value))
-                        .count();
-                    number_of_failures += case_status
-                        .values()
-                        .filter(|value| value.is_some_and(|value| !value))
-                        .count();
-
-                    let mut case_status = case_status
-                        .iter()
-                        .map(|((case_idx, case_name), case_status)| {
-                            (case_idx.into_inner(), case_name, case_status.unwrap())
-                        })
-                        .collect::<Vec<_>>();
-                    case_status.sort_by(|a, b| a.0.cmp(&b.0));
-                    for (case_idx, case_name, case_status) in case_status.into_iter() {
-                        if case_status {
-                            eprintln!(
-                                "  {GREEN}Case Succeeded:{RESET} {} - Case Idx: {case_idx}",
-                                case_name
-                                    .as_ref()
-                                    .map(|string| string.as_str())
-                                    .unwrap_or("Unnamed case")
-                            )
-                        } else {
-                            eprintln!(
-                                "  {RED}Case Failed:{RESET} {} - Case Idx: {case_idx}",
-                                case_name
-                                    .as_ref()
-                                    .map(|string| string.as_str())
-                                    .unwrap_or("Unnamed case")
-                            )
-                        };
-                    }
-                    eprintln!();
-
-                    entries_to_delete.push((metadata_file_path.clone(), solc_mode.clone()));
-                }
-
-                drop(metadata_case_status_read);
-                let mut metadata_case_status_write = metadata_case_status.write().await;
-                for entry in entries_to_delete.drain(..) {
-                    metadata_case_status_write.remove(&entry);
-                }
-
-                tokio::time::sleep(std::time::Duration::from_secs(3)).await;
-            }
-
-            let elapsed = start.elapsed();
-            eprintln!(
-                "{GREEN}{}{RESET} cases succeeded, {RED}{}{RESET} cases failed in {} seconds",
-                number_of_successes,
-                number_of_failures,
-                elapsed.as_secs()
                     );
                 }
-    };
 
+                is_allowed
+            }
+            None => true,
+        })
+        .map(|(metadata_file_path, metadata, case_idx, case, solc_mode)| {
+            Test {
+                metadata: metadata.clone(),
+                path: metadata_file_path.to_path_buf(),
+                mode: solc_mode,
+                case_idx,
+                case: case.clone(),
+            }
+        })
+}
+
+async fn start_driver_task<L, F>(
+    args: &Arguments,
+    tests: impl Iterator<Item = Test>,
+    span: Span,
+    report_tx: mpsc::UnboundedSender<(Test, CaseResult)>,
+) -> anyhow::Result<impl Future<Output = ()>>
+where
+    L: Platform,
+    F: Platform,
+    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
+{
+    let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args).await?);
+    let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args).await?);
     let compilation_cache = Arc::new(RwLock::new(HashMap::new()));
-    let driver_task = futures::stream::iter(test_cases).for_each_concurrent(
+    let number_concurrent_tasks = args.number_of_concurrent_tasks();
-        None,
+
-        |(metadata_file_path, metadata, case_idx, case, solc_mode)| {
+    Ok(futures::stream::iter(tests).for_each_concurrent(
+        // We want to limit the concurrent tasks here because:
+        //
+        // 1. We don't want to overwhelm the nodes with too many requests, leading to responses timing out.
+        // 2. We don't want to open too many files at once, leading to the OS running out of file descriptors.
+        //
+        // By default, we allow maximum of 10 ongoing requests per node in order to limit (1), and assume that
+        // this number will automatically be low enough to address (2). The user can override this.
+        Some(number_concurrent_tasks),
+        move |test| {
+            let leader_nodes = leader_nodes.clone();
+            let follower_nodes = follower_nodes.clone();
             let compilation_cache = compilation_cache.clone();
+            let report_tx = report_tx.clone();
+
+            async move {
                 let leader_node = leader_nodes.round_robbin();
                 let follower_node = follower_nodes.round_robbin();
+
                 let tracing_span = tracing::span!(
                     Level::INFO,
                     "Running driver",
-                metadata_file_path = %metadata_file_path.display(),
+                    metadata_file_path = %test.path.display(),
-                case_idx = case_idx,
+                    case_idx = ?test.case_idx,
-                solc_mode = ?solc_mode,
+                    solc_mode = ?test.mode,
                 );
-            let metadata_case_status = metadata_case_status.clone();
+
-            async move {
                 let result = handle_case_driver::<L, F>(
-                    metadata_file_path.as_path(),
+                    &test.path,
-                    metadata,
+                    &test.metadata,
-                    case_idx.into(),
+                    test.case_idx.into(),
-                    case,
+                    &test.case,
-                    solc_mode.clone(),
+                    test.mode.clone(),
                     args,
                     compilation_cache.clone(),
                     leader_node,
                     follower_node,
                     span,
                 )
-                .await;
-                let mut metadata_case_status = metadata_case_status.write().await;
-                match result {
-                    Ok(inputs_executed) => {
-                        tracing::info!(inputs_executed, "Execution succeeded");
-                        metadata_case_status
-                            .entry((metadata_file_path.clone(), solc_mode))
-                            .or_default()
-                            .insert((CaseIdx::new(case_idx), case.name.clone()), Some(true));
-                    }
-                    Err(error) => {
-                        metadata_case_status
-                            .entry((metadata_file_path.clone(), solc_mode))
-                            .or_default()
-                            .insert((CaseIdx::new(case_idx), case.name.clone()), Some(false));
-                        tracing::error!(%error, "Execution failed")
-                    }
-                }
-                tracing::info!("Execution completed");
-            }
                 .instrument(tracing_span)
+                .await;
+
+                report_tx
+                    .send((test, result))
+                    .expect("Failed to send report");
+            }
         },
+    ))
+}
+
+async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseResult)>) {
+    let start = Instant::now();
+
+    const GREEN: &str = "\x1B[32m";
+    const RED: &str = "\x1B[31m";
+    const COLOUR_RESET: &str = "\x1B[0m";
+    const BOLD: &str = "\x1B[1m";
+    const BOLD_RESET: &str = "\x1B[22m";
+
+    let mut number_of_successes = 0;
+    let mut number_of_failures = 0;
+    let mut failures = vec![];
+
+    // Wait for reports to come from our test runner. When the channel closes, this ends.
+    while let Some((test, case_result)) = report_rx.recv().await {
+        let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
+        let case_idx = test.case_idx;
+        let test_path = test.path.display();
+        let test_mode = test.mode.clone();
+
+        match case_result {
+            Ok(_inputs) => {
+                number_of_successes += 1;
+                eprintln!(
+                    "{GREEN}Case Succeeded:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
                 );
+            }
+            Err(err) => {
+                number_of_failures += 1;
+                eprintln!(
+                    "{RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?})"
+                );
+                failures.push((test, err));
+            }
+        }
+    }
 
-    tokio::join!(status_reporter_task, driver_task);
+    eprintln!();
+    let elapsed = start.elapsed();
 
-    Ok(())
+    // Now, log the failures with more complete errors at the bottom, like `cargo test` does, so
+    // that we don't have to scroll through the entire output to find them.
+    if !failures.is_empty() {
+        eprintln!("{BOLD}Failures:{BOLD_RESET}\n");
+
+        for failure in failures {
+            let (test, err) = failure;
+            let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
+            let case_idx = test.case_idx;
+            let test_path = test.path.display();
+            let test_mode = test.mode.clone();
+
+            eprintln!(
+                "---- {RED}Case Failed:{COLOUR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode:?}) ----\n\n{err}\n"
+            );
+        }
+    }
+
+    // Summary at the end.
+    eprintln!(
+        "{} cases: {GREEN}{number_of_successes}{COLOUR_RESET} cases succeeded, {RED}{number_of_failures}{COLOUR_RESET} cases failed in {} seconds",
+        number_of_successes + number_of_failures,
+        elapsed.as_secs()
+    );
 }
 
 #[allow(clippy::too_many_arguments)]
-async fn handle_case_driver<'a, L, F>(
+async fn handle_case_driver<L, F>(
-    metadata_file_path: &'a Path,
+    metadata_file_path: &Path,
-    metadata: &'a Metadata,
+    metadata: &Metadata,
     case_idx: CaseIdx,
     case: &Case,
     mode: SolcMode,
     config: &Arguments,
-    compilation_cache: CompilationCache<'a>,
+    compilation_cache: CompilationCache,
     leader_node: &L::Blockchain,
     follower_node: &F::Blockchain,
     _: Span,
@@ -446,9 +466,13 @@ where
         // doing the deployments from different accounts and therefore we're not slowed down by
         // the nonce.
         let deployer_address = case
-            .inputs
+            .steps
             .iter()
-            .map(|input| input.caller)
+            .filter_map(|step| match step {
+                Step::FunctionCall(input) => Some(input.caller),
+                Step::BalanceAssertion(..) => None,
+                Step::StorageEmptyAssertion(..) => None,
+            })
             .next()
             .unwrap_or(Input::default_caller());
         let leader_tx = TransactionBuilder::<Ethereum>::with_deploy_code(
@@ -495,11 +519,9 @@ where
         );
 
         let Some(leader_library_address) = leader_receipt.contract_address else {
-            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
         let Some(follower_library_address) = follower_receipt.contract_address else {
-            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
 
@@ -529,8 +551,16 @@ where
         .any(|(code, _)| !code.chars().all(|char| char.is_ascii_hexdigit()));
     let (leader_compiled_contracts, follower_compiled_contracts) =
         if metadata_file_contains_libraries && compiled_contracts_require_linking {
-            let leader_key = (metadata_file_path, mode.clone(), L::config_id());
+            let leader_key = (
-            let follower_key = (metadata_file_path, mode.clone(), L::config_id());
+                metadata_file_path.to_path_buf(),
+                mode.clone(),
+                L::config_id(),
+            );
+            let follower_key = (
+                metadata_file_path.to_path_buf(),
+                mode.clone(),
+                F::config_id(),
+            );
             {
                 let mut cache = compilation_cache.write().await;
                 cache.remove(&leader_key);
@@ -584,15 +614,19 @@ where
     driver.execute().await
 }
 
-async fn get_or_build_contracts<'a, P: Platform>(
+async fn get_or_build_contracts<P: Platform>(
-    metadata: &'a Metadata,
+    metadata: &Metadata,
-    metadata_file_path: &'a Path,
+    metadata_file_path: &Path,
     mode: SolcMode,
     config: &Arguments,
-    compilation_cache: CompilationCache<'a>,
+    compilation_cache: CompilationCache,
     deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
 ) -> anyhow::Result<Arc<(Version, CompilerOutput)>> {
-    let key = (metadata_file_path, mode.clone(), P::config_id());
+    let key = (
+        metadata_file_path.to_path_buf(),
+        mode.clone(),
+        P::config_id(),
+    );
     if let Some(compilation_artifact) = compilation_cache.read().await.get(&key).cloned() {
         let mut compilation_artifact = compilation_artifact.lock().await;
         match *compilation_artifact {
@@ -659,12 +693,12 @@ async fn compile_contracts<P: Platform>(
         "Compiling contracts"
     );
 
-    let compiler = Compiler::<P::Compiler>::new()
+    let mut compiler = Compiler::<P::Compiler>::new()
         .with_allow_path(metadata.directory()?)
         .with_optimization(mode.solc_optimize());
-    let mut compiler = metadata
+    for path in metadata.files_to_compile()? {
-        .files_to_compile()?
+        compiler = compiler.with_source(path).await?;
-        .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
+    }
     for (library_instance, (library_address, _)) in deployed_libraries.iter() {
         let library_ident = &metadata
             .contracts

crates/format/Cargo.toml

@@ -11,6 +11,8 @@ rust-version.workspace = true
 [dependencies]
 revive-dt-common = { workspace = true }
 
+revive-common = { workspace = true }
+
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }

crates/format/src/case.rs

@@ -1,32 +1,50 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
-    input::{Expected, Input},
+    input::{Expected, Step},
     mode::Mode,
 };
 
-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub modes: Option<Vec<Mode>>,
-    pub inputs: Vec<Input>,
+
+    #[serde(rename = "inputs")]
+    pub steps: Vec<Step>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub group: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub expected: Option<Expected>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
 }
 
 impl Case {
-    pub fn inputs_iterator(&self) -> impl Iterator<Item = Input> {
+    #[allow(irrefutable_let_patterns)]
-        let inputs_len = self.inputs.len();
+    pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
-        self.inputs
+        let steps_len = self.steps.len();
+        self.steps
             .clone()
             .into_iter()
             .enumerate()
-            .map(move |(idx, mut input)| {
+            .map(move |(idx, mut step)| {
-                if idx + 1 == inputs_len {
+                let Step::FunctionCall(ref mut input) = step else {
+                    return step;
+                };
+
+                if idx + 1 == steps_len {
                     if input.expected.is_none() {
                         input.expected = self.expected.clone();
                     }
@@ -36,9 +54,9 @@ impl Case {
                     // the case? What are we supposed to do with that final expected field on the
                     // case?
 
-                    input
+                    step
                 } else {
-                    input
+                    step
                 }
             })
     }

crates/format/src/corpus.rs

@@ -39,9 +39,9 @@ impl Corpus {
     }
 
     /// Scan the corpus base directory and return all tests found.
-    pub fn enumerate_tests(&self) -> Vec<MetadataFile> {
+    pub async fn enumerate_tests(&self) -> Vec<MetadataFile> {
         let mut tests = Vec::new();
-        collect_metadata(&self.path, &mut tests);
+        collect_metadata(&self.path, &mut tests).await;
         tests
     }
 }
@@ -52,7 +52,7 @@ impl Corpus {
 /// Found tests are inserted into `tests`.
 ///
 /// `path` is expected to be a directory.
-pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
+pub async fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
     if path.is_dir() {
         let dir_entry = match std::fs::read_dir(path) {
             Ok(dir_entry) => dir_entry,
@@ -73,12 +73,12 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
 
             let path = entry.path();
             if path.is_dir() {
-                collect_metadata(&path, tests);
+                Box::pin(collect_metadata(&path, tests)).await;
                 continue;
             }
 
             if path.is_file() {
-                if let Some(metadata) = MetadataFile::try_from_file(&path) {
+                if let Some(metadata) = MetadataFile::try_from_file(&path).await {
                     tests.push(metadata)
                 }
             }
@@ -89,7 +89,7 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
             return;
         };
         if extension.eq_ignore_ascii_case("sol") || extension.eq_ignore_ascii_case("json") {
-            if let Some(metadata) = MetadataFile::try_from_file(path) {
+            if let Some(metadata) = MetadataFile::try_from_file(path).await {
                 tests.push(metadata)
             }
         } else {

crates/format/src/input.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use alloy::{
     eips::BlockNumberOrTag,
     hex::ToHexExt,
+    json_abi::Function,
     network::TransactionBuilder,
     primitives::{Address, Bytes, U256},
     rpc::types::TransactionRequest,
@@ -17,23 +18,87 @@ use revive_dt_common::macros::define_wrapper_type;
 use crate::traits::ResolverApi;
 use crate::{metadata::ContractInstance, traits::ResolutionContext};
 
-#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+/// A test step.
+///
+/// A test step can be anything. It could be an invocation to a function, an assertion, or any other
+/// action that needs to be run or executed on the nodes used in the tests.
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(untagged)]
+pub enum Step {
+    /// A function call or an invocation to some function on some smart contract.
+    FunctionCall(Box<Input>),
+    /// A step for performing a balance assertion on some account or contract.
+    BalanceAssertion(Box<BalanceAssertion>),
+    /// A step for asserting that the storage of some contract or account is empty.
+    StorageEmptyAssertion(Box<StorageEmptyAssertion>),
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Input {
     #[serde(default = "Input::default_caller")]
     pub caller: Address,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
+
     #[serde(default = "Input::default_instance")]
     pub instance: ContractInstance,
+
     pub method: Method,
+
     #[serde(default)]
     pub calldata: Calldata,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub expected: Option<Expected>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub value: Option<EtherValue>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub storage: Option<HashMap<String, Calldata>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub variable_assignments: Option<VariableAssignments>,
 }
 
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
+pub struct BalanceAssertion {
+    /// An optional comment on the balance assertion.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub comment: Option<String>,
+
+    /// The address that the balance assertion should be done on.
+    ///
+    /// This is a string which will be resolved into an address when being processed. Therefore,
+    /// this could be a normal hex address, a variable such as `Test.address`, or perhaps even a
+    /// full on variable like `$VARIABLE:Uniswap`. It follows the same resolution rules that are
+    /// followed in the calldata.
+    pub address: String,
+
+    /// The amount of balance to assert that the account or contract has.
+    pub expected_balance: U256,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
+pub struct StorageEmptyAssertion {
+    /// An optional comment on the storage empty assertion.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub comment: Option<String>,
+
+    /// The address that the balance assertion should be done on.
+    ///
+    /// This is a string which will be resolved into an address when being processed. Therefore,
+    /// this could be a normal hex address, a variable such as `Test.address`, or perhaps even a
+    /// full on variable like `$VARIABLE:Uniswap`. It follows the same resolution rules that are
+    /// followed in the calldata.
+    pub address: String,
+
+    /// A boolean of whether the storage of the address is empty or not.
+    pub is_storage_empty: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum Expected {
     Calldata(Calldata),
@@ -41,17 +106,21 @@ pub enum Expected {
     ExpectedMany(Vec<ExpectedOutput>),
 }
 
-#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct ExpectedOutput {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub compiler_version: Option<VersionReq>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub return_data: Option<Calldata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub events: Option<Vec<Event>>,
     #[serde(default)]
     pub exception: bool,
 }
 
-#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Event {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub address: Option<String>,
     pub topics: Vec<String>,
     pub values: Calldata,
@@ -108,7 +177,7 @@ pub struct Event {
 /// [`Single`]: Calldata::Single
 /// [`Compound`]: Calldata::Compound
 /// [reverse polish notation]: https://en.wikipedia.org/wiki/Reverse_Polish_notation
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum Calldata {
     Single(Bytes),
@@ -142,7 +211,7 @@ enum Operation {
 }
 
 /// Specify how the contract is called.
-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub enum Method {
     /// Initiate a deploy transaction, calling contracts constructor.
     ///
@@ -167,7 +236,7 @@ define_wrapper_type!(
     pub struct EtherValue(U256);
 );
 
-#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct VariableAssignments {
     /// A vector of the variable names to assign to the return data.
     ///
@@ -211,9 +280,17 @@ impl Input {
                 // We follow the same logic that's implemented in the matter-labs-tester where they resolve
                 // the function name into a function selector and they assume that he function doesn't have
                 // any existing overloads.
+                // Overloads are handled by providing the full function signature in the "function
+                // name".
                 // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-                let function = abi
+                let selector = if function_name.contains('(') && function_name.contains(')') {
-                    .functions()
+                    Function::parse(function_name)
+                        .context(
+                            "Failed to parse the provided function name into a function signature",
+                        )?
+                        .selector()
+                } else {
+                    abi.functions()
                         .find(|function| function.signature().starts_with(function_name))
                         .ok_or_else(|| {
                             anyhow::anyhow!(
@@ -221,7 +298,9 @@ impl Input {
                                 function_name,
                                 &self.instance
                             )
-                    })?;
+                        })?
+                        .selector()
+                };
 
                 tracing::trace!("Functions found for instance: {}", self.instance.as_ref());
 
@@ -237,7 +316,7 @@ impl Input {
                 // We're using indices in the following code in order to avoid the need for us to allocate
                 // a new buffer for each one of the resolved arguments.
                 let mut calldata = Vec::<u8>::with_capacity(4 + self.calldata.size_requirement());
-                calldata.extend(function.selector().0);
+                calldata.extend(selector.0);
                 self.calldata
                     .calldata_into_slice(&mut calldata, resolver, context)
                     .await?;

crates/format/src/metadata.rs

@@ -1,7 +1,7 @@
 use std::{
+    cmp::Ordering,
     collections::BTreeMap,
     fmt::Display,
-    fs::{File, read_to_string},
     ops::Deref,
     path::{Path, PathBuf},
     str::FromStr,
@@ -9,7 +9,10 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
-use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wrapper_type};
+use revive_common::EVMVersion;
+use revive_dt_common::{
+    fs::CachedFileSystem, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
+};
 
 use crate::{
     case::Case,
@@ -27,8 +30,8 @@ pub struct MetadataFile {
 }
 
 impl MetadataFile {
-    pub fn try_from_file(path: &Path) -> Option<Self> {
+    pub async fn try_from_file(path: &Path) -> Option<Self> {
-        Metadata::try_from_file(path).map(|metadata| Self {
+        Metadata::try_from_file(path).await.map(|metadata| Self {
             path: path.to_owned(),
             content: metadata,
         })
@@ -43,16 +46,42 @@ impl Deref for MetadataFile {
     }
 }
 
-#[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
-    pub targets: Option<Vec<String>>,
+    /// A comment on the test case that's added for human-readability.
-    pub cases: Vec<Case>,
+    #[serde(skip_serializing_if = "Option::is_none")]
-    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
+    pub comment: Option<String>,
-    // TODO: Convert into wrapper types for clarity.
+
-    pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub targets: Option<Vec<String>>,
+
+    pub cases: Vec<Case>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub modes: Option<Vec<Mode>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
+
+    /// This field specifies an EVM version requirement that the test case has where the test might
+    /// be run of the evm version of the nodes match the evm version specified here.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub required_evm_version: Option<EvmVersionRequirement>,
+
+    /// A set of compilation directives that will be passed to the compiler whenever the contracts for
+    /// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
+    /// just a filter for when a test can run whereas this is an instruction to the compiler.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub compiler_directives: Option<CompilationDirectives>,
 }
 
 impl Metadata {
@@ -123,7 +152,7 @@ impl Metadata {
     ///
     /// # Panics
     /// Expects the supplied `path` to be a file.
-    pub fn try_from_file(path: &Path) -> Option<Self> {
+    pub async fn try_from_file(path: &Path) -> Option<Self> {
         assert!(path.is_file(), "not a file: {}", path.display());
 
         let Some(file_extension) = path.extension() else {
@@ -132,19 +161,20 @@ impl Metadata {
         };
 
         if file_extension == METADATA_FILE_EXTENSION {
-            return Self::try_from_json(path);
+            return Self::try_from_json(path).await;
         }
 
         if file_extension == SOLIDITY_CASE_FILE_EXTENSION {
-            return Self::try_from_solidity(path);
+            return Self::try_from_solidity(path).await;
         }
 
         tracing::debug!("ignoring invalid corpus file: {}", path.display());
         None
     }
 
-    fn try_from_json(path: &Path) -> Option<Self> {
+    async fn try_from_json(path: &Path) -> Option<Self> {
-        let file = File::open(path)
+        let content = CachedFileSystem::read(path)
+            .await
             .inspect_err(|error| {
                 tracing::error!(
                     "opening JSON test metadata file '{}' error: {error}",
@@ -153,7 +183,7 @@ impl Metadata {
             })
             .ok()?;
 
-        match serde_json::from_reader::<_, Metadata>(file) {
+        match serde_json::from_slice::<Metadata>(content.as_slice()) {
             Ok(mut metadata) => {
                 metadata.file_path = Some(path.to_path_buf());
                 Some(metadata)
@@ -168,8 +198,9 @@ impl Metadata {
         }
     }
 
-    fn try_from_solidity(path: &Path) -> Option<Self> {
+    async fn try_from_solidity(path: &Path) -> Option<Self> {
-        let spec = read_to_string(path)
+        let spec = CachedFileSystem::read_to_string(path)
+            .await
             .inspect_err(|error| {
                 tracing::error!(
                     "opening JSON test metadata file '{}' error: {error}",
@@ -343,6 +374,156 @@ impl From<ContractPathAndIdent> for String {
     }
 }
 
+/// An EVM version requirement that the test case has. This gets serialized and
+/// deserialized from and into [`String`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct EvmVersionRequirement {
+    ordering: Ordering,
+    or_equal: bool,
+    evm_version: EVMVersion,
+}
+
+impl EvmVersionRequirement {
+    pub fn new_greater_than_or_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Greater,
+            or_equal: true,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_greater_than(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Greater,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Equal,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_less_than(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Less,
+            or_equal: false,
+            evm_version: version,
+        }
+    }
+
+    pub fn new_less_than_or_equals(version: EVMVersion) -> Self {
+        Self {
+            ordering: Ordering::Less,
+            or_equal: true,
+            evm_version: version,
+        }
+    }
+
+    pub fn matches(&self, other: &EVMVersion) -> bool {
+        let ordering = other.cmp(&self.evm_version);
+        ordering == self.ordering || (self.or_equal && matches!(ordering, Ordering::Equal))
+    }
+}
+
+impl Display for EvmVersionRequirement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self {
+            ordering,
+            or_equal,
+            evm_version,
+        } = self;
+        match ordering {
+            Ordering::Less => write!(f, "<")?,
+            Ordering::Equal => write!(f, "=")?,
+            Ordering::Greater => write!(f, ">")?,
+        }
+        if *or_equal && !matches!(ordering, Ordering::Equal) {
+            write!(f, "=")?;
+        }
+        write!(f, "{evm_version}")
+    }
+}
+
+impl FromStr for EvmVersionRequirement {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.as_bytes() {
+            [b'>', b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Greater,
+                or_equal: true,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'>', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Greater,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'<', b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Less,
+                or_equal: true,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'<', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Less,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            [b'=', remaining @ ..] => Ok(Self {
+                ordering: Ordering::Equal,
+                or_equal: false,
+                evm_version: str::from_utf8(remaining)?.try_into()?,
+            }),
+            _ => anyhow::bail!("Invalid EVM version requirement {s}"),
+        }
+    }
+}
+
+impl TryFrom<String> for EvmVersionRequirement {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}
+
+impl From<EvmVersionRequirement> for String {
+    fn from(value: EvmVersionRequirement) -> Self {
+        value.to_string()
+    }
+}
+
+/// A set of compilation directives that will be passed to the compiler whenever the contracts for
+/// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
+/// just a filter for when a test can run whereas this is an instruction to the compiler.
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+pub struct CompilationDirectives {
+    /// Defines how the revert strings should be handled.
+    pub revert_string_handling: Option<RevertString>,
+}
+
+/// Defines how the compiler should handle revert strings.
+#[derive(
+    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
+)]
+#[serde(rename_all = "camelCase")]
+pub enum RevertString {
+    #[default]
+    Default,
+    Debug,
+    Strip,
+    VerboseDebug,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

crates/format/src/mode.rs

@@ -16,6 +16,7 @@ pub struct SolcMode {
     pub solc_version: Option<semver::VersionReq>,
     solc_optimize: Option<bool>,
     pub llvm_optimizer_settings: Vec<String>,
+    mode_string: String,
 }
 
 impl SolcMode {
@@ -29,7 +30,10 @@ impl SolcMode {
     /// - A solc `SemVer version requirement` string
     /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
     pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
-        let mut result = Self::default();
+        let mut result = Self {
+            mode_string: mode_string.to_string(),
+            ..Default::default()
+        };
 
         let mut parts = mode_string.trim().split(" ");
 
@@ -104,3 +108,16 @@ impl<'de> Deserialize<'de> for Mode {
         Ok(Self::Unknown(mode_string))
     }
 }
+
+impl Serialize for Mode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let string = match self {
+            Mode::Solidity(solc_mode) => &solc_mode.mode_string,
+            Mode::Unknown(string) => string,
+        };
+        string.serialize(serializer)
+    }
+}

crates/node-interaction/src/lib.rs

@@ -1,7 +1,8 @@
 //! This crate implements all node interactions.
 
+use alloy::primitives::{Address, StorageKey, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
-use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
+use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
 use anyhow::Result;
 
 /// An interface for all interactions with Ethereum compatible nodes.
@@ -21,4 +22,14 @@ pub trait EthereumNode {
 
     /// Returns the state diff of the transaction hash in the [TransactionReceipt].
     fn state_diff(&self, receipt: &TransactionReceipt) -> impl Future<Output = Result<DiffMode>>;
+
+    /// Returns the balance of the provided [`Address`] back.
+    fn balance_of(&self, address: Address) -> impl Future<Output = Result<U256>>;
+
+    /// Returns the latest storage proof of the provided [`Address`]
+    fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> impl Future<Output = Result<EIP1186AccountProofResponse>>;
 }

crates/node/Cargo.toml

@@ -14,6 +14,7 @@ alloy = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true }
 
+revive-common = { workspace = true }
 revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }

crates/node/src/geth.rs

@@ -17,19 +17,22 @@ use alloy::{
     eips::BlockNumberOrTag,
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, TxHash, U256},
+    primitives::{
+        Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, StorageKey, TxHash, U256,
+    },
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
     },
     rpc::types::{
-        TransactionReceipt, TransactionRequest,
+        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
     signers::local::PrivateKeySigner,
 };
 use anyhow::Context;
+use revive_common::EVMVersion;
 use tracing::{Instrument, Level};
 
 use revive_dt_common::{fs::clear_directory, futures::poll};
@@ -89,7 +92,7 @@ impl GethNode {
     const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);
 
     /// Create the node directory and call `geth init` to configure the genesis.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
@@ -139,7 +142,7 @@ impl GethNode {
     /// Spawn the go-ethereum node child process.
     ///
     /// [Instance::init] must be called prior.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
         // This is the `OpenOptions` that we wish to use for all of the log files that we will be
         // opening in this method. We need to construct it in this way to:
@@ -197,7 +200,7 @@ impl GethNode {
     /// Wait for the g-ethereum node child process getting ready.
     ///
     /// [Instance::spawn_process] must be called priorly.
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
         let start_time = Instant::now();
 
@@ -266,7 +269,7 @@ impl GethNode {
 }
 
 impl EthereumNode for GethNode {
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
@@ -322,7 +325,7 @@ impl EthereumNode for GethNode {
         .await
     }
 
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
@@ -355,7 +358,7 @@ impl EthereumNode for GethNode {
         .await
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -371,10 +374,33 @@ impl EthereumNode for GethNode {
             _ => anyhow::bail!("expected a diff mode trace"),
         }
     }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
+        self.provider()
+            .await?
+            .get_balance(address)
+            .await
+            .map_err(Into::into)
+    }
+
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
+    async fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> anyhow::Result<EIP1186AccountProofResponse> {
+        self.provider()
+            .await?
+            .get_proof(address, keys)
+            .latest()
+            .await
+            .map_err(Into::into)
+    }
 }
 
 impl ResolverApi for GethNode {
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
             .await?
@@ -383,7 +409,7 @@ impl ResolverApi for GethNode {
             .map_err(Into::into)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -393,7 +419,7 @@ impl ResolverApi for GethNode {
             .map(|receipt| receipt.effective_gas_price)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -403,7 +429,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.gas_limit as _)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
             .await?
@@ -413,7 +439,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.beneficiary)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -423,7 +449,7 @@ impl ResolverApi for GethNode {
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
             .await?
@@ -438,7 +464,7 @@ impl ResolverApi for GethNode {
             })
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
             .await?
@@ -448,7 +474,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.hash)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
             .await?
@@ -458,7 +484,7 @@ impl ResolverApi for GethNode {
             .map(|block| block.header.timestamp)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
             .await?
@@ -501,12 +527,12 @@ impl Node for GethNode {
         }
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn connection_string(&self) -> String {
         self.connection_string.clone()
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.handle.take() {
@@ -528,13 +554,13 @@ impl Node for GethNode {
         Ok(())
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(genesis)?.spawn_process()?;
         Ok(())
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.geth)
             .arg("--version")
@@ -547,17 +573,21 @@ impl Node for GethNode {
         Ok(String::from_utf8_lossy(&output).into())
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn matches_target(&self, targets: Option<&[String]>) -> bool {
         match targets {
             None => true,
             Some(targets) => targets.iter().any(|str| str.as_str() == "evm"),
         }
     }
+
+    fn evm_version() -> EVMVersion {
+        EVMVersion::Cancun
+    }
 }
 
 impl Drop for GethNode {
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn drop(&mut self) {
         self.shutdown().expect("Failed to shutdown")
     }

crates/node/src/kitchensink.rs

@@ -17,7 +17,7 @@ use alloy::{
     },
     primitives::{
         Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes,
-        TxHash, U256,
+        StorageKey, TxHash, U256,
     },
     providers::{
         Provider, ProviderBuilder,
@@ -25,13 +25,14 @@ use alloy::{
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
     },
     rpc::types::{
-        TransactionReceipt,
+        EIP1186AccountProofResponse, TransactionReceipt,
         eth::{Block, Header, Transaction},
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
     signers::local::PrivateKeySigner,
 };
 use anyhow::Context;
+use revive_common::EVMVersion;
 use revive_dt_common::fs::clear_directory;
 use revive_dt_format::traits::ResolverApi;
 use serde::{Deserialize, Serialize};
@@ -159,7 +160,7 @@ impl KitchensinkNode {
         Ok(self)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn_process(&mut self) -> anyhow::Result<()> {
         let substrate_rpc_port = Self::BASE_SUBSTRATE_RPC_PORT + self.id as u16;
         let proxy_rpc_port = Self::BASE_PROXY_RPC_PORT + self.id as u16;
@@ -257,7 +258,7 @@ impl KitchensinkNode {
         Ok(())
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn extract_balance_from_genesis_file(
         &self,
         genesis: &Genesis,
@@ -306,7 +307,7 @@ impl KitchensinkNode {
         }
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.eth_proxy_binary)
             .arg("--version")
@@ -381,7 +382,7 @@ impl KitchensinkNode {
 }
 
 impl EthereumNode for KitchensinkNode {
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn execute_transaction(
         &self,
         transaction: alloy::rpc::types::TransactionRequest,
@@ -398,7 +399,7 @@ impl EthereumNode for KitchensinkNode {
         Ok(receipt)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
@@ -412,7 +413,7 @@ impl EthereumNode for KitchensinkNode {
             .await?)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn state_diff(&self, transaction: &TransactionReceipt) -> anyhow::Result<DiffMode> {
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
@@ -428,10 +429,33 @@ impl EthereumNode for KitchensinkNode {
             _ => anyhow::bail!("expected a diff mode trace"),
         }
     }
+
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
+    async fn balance_of(&self, address: Address) -> anyhow::Result<U256> {
+        self.provider()
+            .await?
+            .get_balance(address)
+            .await
+            .map_err(Into::into)
+    }
+
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
+    async fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> anyhow::Result<EIP1186AccountProofResponse> {
+        self.provider()
+            .await?
+            .get_proof(address, keys)
+            .latest()
+            .await
+            .map_err(Into::into)
+    }
 }
 
 impl ResolverApi for KitchensinkNode {
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         self.provider()
             .await?
@@ -440,7 +464,7 @@ impl ResolverApi for KitchensinkNode {
             .map_err(Into::into)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -450,7 +474,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|receipt| receipt.effective_gas_price)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
             .await?
@@ -460,7 +484,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.gas_limit as _)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
         self.provider()
             .await?
@@ -470,7 +494,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.beneficiary)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
         self.provider()
             .await?
@@ -480,7 +504,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
         self.provider()
             .await?
@@ -495,7 +519,7 @@ impl ResolverApi for KitchensinkNode {
             })
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_hash(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
         self.provider()
             .await?
@@ -505,7 +529,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.hash)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn block_timestamp(&self, number: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
         self.provider()
             .await?
@@ -515,7 +539,7 @@ impl ResolverApi for KitchensinkNode {
             .map(|block| block.header.timestamp)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
         self.provider()
             .await?
@@ -563,7 +587,7 @@ impl Node for KitchensinkNode {
         self.rpc_url.clone()
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn shutdown(&mut self) -> anyhow::Result<()> {
         // Terminate the processes in a graceful manner to allow for the output to be flushed.
         if let Some(mut child) = self.process_proxy.take() {
@@ -590,12 +614,12 @@ impl Node for KitchensinkNode {
         Ok(())
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn spawn(&mut self, genesis: String) -> anyhow::Result<()> {
         self.init(&genesis)?.spawn_process()
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id), err)]
     fn version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.substrate_binary)
             .arg("--version")
@@ -615,6 +639,10 @@ impl Node for KitchensinkNode {
             Some(targets) => targets.iter().any(|str| str.as_str() == "pvm"),
         }
     }
+
+    fn evm_version() -> EVMVersion {
+        EVMVersion::Cancun
+    }
 }
 
 impl Drop for KitchensinkNode {

crates/node/src/lib.rs

@@ -1,5 +1,6 @@
 //! This crate implements the testing nodes.
 
+use revive_common::EVMVersion;
 use revive_dt_config::Arguments;
 use revive_dt_node_interaction::EthereumNode;
 
@@ -36,4 +37,7 @@ pub trait Node: EthereumNode {
     /// Given a list of targets from the metadata file, this function determines if the metadata
     /// file can be ran on this node or not.
     fn matches_target(&self, targets: Option<&[String]>) -> bool;
+
+    /// Returns the EVM version of the node.
+    fn evm_version() -> EVMVersion;
 }

crates/node/src/pool.rs

@@ -1,12 +1,12 @@
 //! This crate implements concurrent handling of testing node.
 
 use std::{
-    fs::read_to_string,
     sync::atomic::{AtomicUsize, Ordering},
     thread,
 };
 
 use anyhow::Context;
+use revive_dt_common::fs::CachedFileSystem;
 use revive_dt_config::Arguments;
 
 use crate::Node;
@@ -23,12 +23,11 @@ where
     T: Node + Send + 'static,
 {
     /// Create a new Pool. This will start as many nodes as there are workers in `config`.
-    pub fn new(config: &Arguments) -> anyhow::Result<Self> {
+    pub async fn new(config: &Arguments) -> anyhow::Result<Self> {
         let nodes = config.number_of_nodes;
-        let genesis = read_to_string(&config.genesis_file).context(format!(
+        let genesis = CachedFileSystem::read_to_string(&config.genesis_file)
-            "can not read genesis file: {}",
+            .await
-            config.genesis_file.display()
+            .context("Failed to read genesis file")?;
-        ))?;
 
         let mut handles = Vec::with_capacity(nodes);
         for _ in 0..nodes {