Print to the stderr and print logs to stdout

Cargo.lock

@@ -2929,12 +2929,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "indoc"
-version = "2.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
-
 [[package]]
 name = "integer-sqrt"
 version = "0.1.5"
@@ -4036,7 +4030,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "semver 1.0.26",
- "tokio",
 ]
 
 [[package]]
@@ -4101,9 +4094,6 @@ dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
  "anyhow",
- "indoc",
- "regex",
- "revive-common",
  "revive-dt-common",
  "semver 1.0.26",
  "serde",

Cargo.toml

@@ -30,7 +30,6 @@ foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
 reqwest = { version = "0.12.15", features = ["json"] }
-regex = { version = "1.11.1" }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
@@ -56,7 +55,6 @@ tracing-subscriber = { version = "0.3.19", default-features = false, features =
     "env-filter",
 ] }
 indexmap = { version = "2.10.0", default-features = false }
-indoc = { version = "2.0.6", default-features = false }
 
 # revive compiler
 revive-solc-json-interface = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }

crates/common/Cargo.toml

@@ -11,4 +11,3 @@ rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 semver = { workspace = true }
-tokio = { workspace = true, default-features = false, features = ["time"] }

crates/common/src/futures/mod.rs

@@ -1,3 +0,0 @@
-mod poll;
-
-pub use poll::*;

crates/common/src/futures/poll.rs

@@ -1,69 +0,0 @@
-use std::ops::ControlFlow;
-use std::time::Duration;
-
-use anyhow::{Result, anyhow};
-
-const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
-
-/// A function that polls for a fallible future for some period of time and errors if it fails to
-/// get a result after polling.
-///
-/// Given a future that returns a [`Result<ControlFlow<O, ()>>`], this function calls the future
-/// repeatedly (with some wait period) until the future returns a [`ControlFlow::Break`] or until it
-/// returns an [`Err`] in which case the function stops polling and returns the error.
-///
-/// If the future keeps returning [`ControlFlow::Continue`] and fails to return a [`Break`] within
-/// the permitted polling duration then this function returns an [`Err`]
-///
-/// [`Break`]: ControlFlow::Break
-/// [`Continue`]: ControlFlow::Continue
-pub async fn poll<F, O>(
-    polling_duration: Duration,
-    polling_wait_behavior: PollingWaitBehavior,
-    mut future: impl FnMut() -> F,
-) -> Result<O>
-where
-    F: Future<Output = Result<ControlFlow<O, ()>>>,
-{
-    let mut retries = 0;
-    let mut total_wait_duration = Duration::ZERO;
-    let max_allowed_wait_duration = polling_duration;
-
-    loop {
-        if total_wait_duration >= max_allowed_wait_duration {
-            break Err(anyhow!(
-                "Polling failed after {} retries and a total of {:?} of wait time",
-                retries,
-                total_wait_duration
-            ));
-        }
-
-        match future().await? {
-            ControlFlow::Continue(()) => {
-                let next_wait_duration = match polling_wait_behavior {
-                    PollingWaitBehavior::Constant(duration) => duration,
-                    PollingWaitBehavior::ExponentialBackoff => {
-                        Duration::from_secs(2u64.pow(retries))
-                            .min(EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION)
-                    }
-                };
-                let next_wait_duration =
-                    next_wait_duration.min(max_allowed_wait_duration - total_wait_duration);
-                total_wait_duration += next_wait_duration;
-                retries += 1;
-
-                tokio::time::sleep(next_wait_duration).await;
-            }
-            ControlFlow::Break(output) => {
-                break Ok(output);
-            }
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-pub enum PollingWaitBehavior {
-    Constant(Duration),
-    #[default]
-    ExponentialBackoff,
-}

crates/common/src/iterators/files_with_extension_iterator.rs

@@ -1,8 +1,4 @@
-use std::{
+use std::{borrow::Cow, collections::HashSet, path::PathBuf};
-    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`
@@ -22,10 +18,10 @@ pub struct FilesWithExtensionIterator {
 }
 
 impl FilesWithExtensionIterator {
-    pub fn new(root_directory: impl AsRef<Path>) -> Self {
+    pub fn new(root_directory: PathBuf) -> Self {
         Self {
             allowed_extensions: Default::default(),
-            directories_to_search: vec![root_directory.as_ref().to_path_buf()],
+            directories_to_search: vec![root_directory],
             files_matching_allowed_extensions: Default::default(),
         }
     }

crates/common/src/lib.rs

@@ -2,7 +2,6 @@
 //! the workspace can benefit from.
 
 pub mod fs;
-pub mod futures;
 pub mod iterators;
 pub mod macros;
 pub mod types;

crates/compiler/src/solc.rs

@@ -238,25 +238,4 @@ mod test {
             Version::new(0, 7, 6)
         )
     }
-
-    #[tokio::test]
-    async fn compiler_version_can_be_obtained1() {
-        // Arrange
-        let args = Arguments::default();
-        println!("Getting compiler path");
-        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
-            .await
-            .unwrap();
-        println!("Got compiler path");
-        let compiler = Solc::new(path);
-
-        // Act
-        let version = compiler.version();
-
-        // Assert
-        assert_eq!(
-            version.expect("Failed to get version"),
-            Version::new(0, 4, 21)
-        )
-    }
 }

crates/config/src/lib.rs

@@ -77,7 +77,7 @@ pub struct Arguments {
     /// This argument controls which private keys the nodes should have access to and be added to
     /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
     /// of the node.
-    #[arg(long = "private-keys-count", default_value_t = 100_000)]
+    #[arg(long = "private-keys-count", default_value_t = 15_000)]
     pub private_keys_to_add: usize,
 
     /// The differential testing leader node implementation.

crates/core/src/driver/mod.rs

@@ -4,7 +4,6 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
-use alloy::hex;
 use alloy::json_abi::JsonAbi;
 use alloy::network::{Ethereum, TransactionBuilder};
 use alloy::primitives::U256;
@@ -22,7 +21,6 @@ use alloy::{
 };
 use anyhow::Context;
 use indexmap::IndexMap;
-use revive_dt_format::traits::{ResolutionContext, ResolverApi};
 use semver::Version;
 
 use revive_dt_format::case::{Case, CaseIdx};
@@ -31,7 +29,6 @@ use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Input, metadata::Metadata};
 use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
-use tracing::Instrument;
 
 use crate::Platform;
 
@@ -164,7 +161,7 @@ where
                 .context("Failed to find deployment receipt"),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = match input
-                    .legacy_transaction(node, self.default_resolution_context())
+                    .legacy_transaction(&self.deployed_contracts, &self.variables, node)
                     .await
                 {
                     Ok(tx) => {
@@ -236,11 +233,6 @@ where
         ) {
             let value = U256::from_be_slice(output_word);
             self.variables.insert(variable_name.clone(), value);
-            tracing::info!(
-                variable_name,
-                variable_value = hex::encode(value.to_be_bytes::<32>()),
-                "Assigned variable"
-            );
         }
 
         Ok(())
@@ -250,7 +242,7 @@ where
         &mut self,
         input: &Input,
         execution_receipt: &TransactionReceipt,
-        resolver: &impl ResolverApi,
+        node: &T::Blockchain,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
         let span = tracing::info_span!("Handling input expectations");
@@ -287,7 +279,7 @@ where
         for expectation in expectations.iter() {
             self.handle_input_expectation_item(
                 execution_receipt,
-                resolver,
+                node,
                 expectation,
                 tracing_result,
             )
@@ -300,7 +292,7 @@ where
     async fn handle_input_expectation_item(
         &mut self,
         execution_receipt: &TransactionReceipt,
-        resolver: &impl ResolverApi,
+        node: &T::Blockchain,
         expectation: &ExpectedOutput,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
@@ -310,10 +302,9 @@ where
             }
         }
 
-        let resolution_context = self
+        let deployed_contracts = &mut self.deployed_contracts;
-            .default_resolution_context()
+        let variables = &mut self.variables;
-            .with_block_number(execution_receipt.block_number.as_ref())
+        let chain_state_provider = node;
-            .with_transaction_hash(&execution_receipt.transaction_hash);
 
         // Handling the receipt state assertion.
         let expected = !expectation.exception;
@@ -336,7 +327,12 @@ where
             let expected = expected_calldata;
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
-                .is_equivalent(actual, resolver, resolution_context)
+                .is_equivalent(
+                    actual,
+                    deployed_contracts,
+                    &*variables,
+                    chain_state_provider,
+                )
                 .await?
             {
                 tracing::error!(
@@ -362,16 +358,14 @@ where
             }
 
             // Handling the events assertion.
-            for (event_idx, (expected_event, actual_event)) in expected_events
+            for (expected_event, actual_event) in
-                .iter()
+                expected_events.iter().zip(execution_receipt.logs())
-                .zip(execution_receipt.logs())
-                .enumerate()
             {
                 // Handling the emitter assertion.
                 if let Some(ref expected_address) = expected_event.address {
                     let expected = Address::from_slice(
                         Calldata::new_compound([expected_address])
-                            .calldata(resolver, resolution_context)
+                            .calldata(deployed_contracts, &*variables, node)
                             .await?
                             .get(12..32)
                             .expect("Can't fail"),
@@ -379,7 +373,6 @@ where
                     let actual = actual_event.address();
                     if actual != expected {
                         tracing::error!(
-                            event_idx,
                             %expected,
                             %actual,
                             "Event emitter assertion failed",
@@ -399,11 +392,15 @@ where
                 {
                     let expected = Calldata::new_compound([expected]);
                     if !expected
-                        .is_equivalent(&actual.0, resolver, resolution_context)
+                        .is_equivalent(
+                            &actual.0,
+                            deployed_contracts,
+                            &*variables,
+                            chain_state_provider,
+                        )
                         .await?
                     {
                         tracing::error!(
-                            event_idx,
                             ?execution_receipt,
                             ?expected,
                             ?actual,
@@ -419,11 +416,15 @@ where
                 let expected = &expected_event.values;
                 let actual = &actual_event.data().data;
                 if !expected
-                    .is_equivalent(&actual.0, resolver, resolution_context)
+                    .is_equivalent(
+                        &actual.0,
+                        deployed_contracts,
+                        &*variables,
+                        chain_state_provider,
+                    )
                     .await?
                 {
                     tracing::error!(
-                        event_idx,
                         ?execution_receipt,
                         ?expected,
                         ?actual,
@@ -525,7 +526,7 @@ where
 
         if let Some(calldata) = calldata {
             let calldata = calldata
-                .calldata(node, self.default_resolution_context())
+                .calldata(&self.deployed_contracts, None, node)
                 .await?;
             code.extend(calldata);
         }
@@ -566,12 +567,6 @@ where
 
         Ok((address, abi, Some(receipt)))
     }
-
-    fn default_resolution_context(&self) -> ResolutionContext<'_> {
-        ResolutionContext::default()
-            .with_deployed_contracts(&self.deployed_contracts)
-            .with_variables(&self.variables)
-    }
 }
 
 pub struct CaseDriver<'a, Leader: Platform, Follower: Platform> {
@@ -654,16 +649,15 @@ where
         let mut inputs_executed = 0;
         for (input_idx, input) in self.case.inputs_iterator().enumerate() {
             let tracing_span = tracing::info_span!("Handling input", input_idx);
+            let _guard = tracing_span.enter();
 
             let (leader_receipt, _, leader_diff) = self
                 .leader_state
                 .handle_input(self.metadata, self.case_idx, &input, self.leader_node)
-                .instrument(tracing_span.clone())
                 .await?;
             let (follower_receipt, _, follower_diff) = self
                 .follower_state
                 .handle_input(self.metadata, self.case_idx, &input, self.follower_node)
-                .instrument(tracing_span)
                 .await?;
 
             if leader_diff == follower_diff {

crates/core/src/main.rs

@@ -2,7 +2,6 @@ use std::{
     collections::HashMap,
     path::Path,
     sync::{Arc, LazyLock},
-    time::Instant,
 };
 
 use alloy::{
@@ -151,32 +150,6 @@ where
                     })
             },
         )
-        .filter(
-            |(metadata_file_path, metadata, _, _, _)| match metadata.ignore {
-                Some(true) => {
-                    tracing::warn!(
-                        metadata_file_path = %metadata_file_path.display(),
-                        "Ignoring metadata file"
-                    );
-                    false
-                }
-                Some(false) | None => true,
-            },
-        )
-        .filter(
-            |(metadata_file_path, _, case_idx, case, _)| match case.ignore {
-                Some(true) => {
-                    tracing::warn!(
-                        metadata_file_path = %metadata_file_path.display(),
-                        case_idx,
-                        case_name = ?case.name,
-                        "Ignoring case"
-                    );
-                    false
-                }
-                Some(false) | None => true,
-            },
-        )
         .collect::<Vec<_>>();
 
     let metadata_case_status = Arc::new(RwLock::new(test_cases.iter().fold(
@@ -190,15 +163,12 @@ where
     )));
     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() {
@@ -234,15 +204,6 @@ where
                         )
                     };
 
-                    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)| {
@@ -250,10 +211,10 @@ where
                         })
                         .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() {
+                    for (_, case_name, case_status) in case_status.into_iter() {
                         if case_status {
                             eprintln!(
-                                "  {GREEN}Case Succeeded:{RESET} {} - Case Idx: {case_idx}",
+                                "{GREEN}  Case Succeeded:{RESET} {}",
                                 case_name
                                     .as_ref()
                                     .map(|string| string.as_str())
@@ -261,7 +222,7 @@ where
                             )
                         } else {
                             eprintln!(
-                                "  {RED}Case Failed:{RESET} {} - Case Idx: {case_idx}",
+                                "{RED}  Case Failed:{RESET} {}",
                                 case_name
                                     .as_ref()
                                     .map(|string| string.as_str())
@@ -282,14 +243,6 @@ where
 
                 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()
-            );
         }
     };
 
@@ -336,7 +289,7 @@ where
                             .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!(%error, "Execution failed")
                     }
                 }
                 tracing::info!("Execution completed");
@@ -483,17 +436,6 @@ where
             }
         };
 
-        tracing::info!(
-            ?library_instance,
-            library_address = ?leader_receipt.contract_address,
-            "Deployed library to leader"
-        );
-        tracing::info!(
-            ?library_instance,
-            library_address = ?follower_receipt.contract_address,
-            "Deployed library to follower"
-        );
-
         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");
@@ -603,14 +545,7 @@ async fn get_or_build_contracts<'a, P: Platform>(
             None => {
                 tracing::debug!(?key, "Compiled contracts cache miss");
                 let compiled_contracts = Arc::new(
-                    compile_contracts::<P>(
+                    compile_contracts::<P>(metadata, &mode, config, deployed_libraries).await?,
-                        metadata,
-                        metadata_file_path,
-                        &mode,
-                        config,
-                        deployed_libraries,
-                    )
-                    .await?,
                 );
                 *compilation_artifact = Some(compiled_contracts.clone());
                 return Ok(compiled_contracts.clone());
@@ -626,23 +561,14 @@ async fn get_or_build_contracts<'a, P: Platform>(
         mutex
     };
     let mut compilation_artifact = mutex.lock().await;
-    let compiled_contracts = Arc::new(
+    let compiled_contracts =
-        compile_contracts::<P>(
+        Arc::new(compile_contracts::<P>(metadata, &mode, config, deployed_libraries).await?);
-            metadata,
-            metadata_file_path,
-            &mode,
-            config,
-            deployed_libraries,
-        )
-        .await?,
-    );
     *compilation_artifact = Some(compiled_contracts.clone());
     Ok(compiled_contracts.clone())
 }
 
 async fn compile_contracts<P: Platform>(
     metadata: &Metadata,
-    metadata_file_path: &Path,
     mode: &SolcMode,
     config: &Arguments,
     deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
@@ -652,13 +578,6 @@ async fn compile_contracts<P: Platform>(
         P::Compiler::get_compiler_executable(config, compiler_version_or_requirement).await?;
     let compiler_version = P::Compiler::new(compiler_path.clone()).version()?;
 
-    tracing::info!(
-        %compiler_version,
-        metadata_file_path = %metadata_file_path.display(),
-        mode = ?mode,
-        "Compiling contracts"
-    );
-
     let compiler = Compiler::<P::Compiler>::new()
         .with_allow_path(metadata.directory()?)
         .with_optimization(mode.solc_optimize());
@@ -673,11 +592,11 @@ async fn compile_contracts<P: Platform>(
             .expect("Impossible for library to not be found in contracts")
             .contract_ident;
 
-        // Note the following: we need to tell solc which files require the libraries to be linked
+        // Note the following: we need to tell solc which files require the libraries to be
-        // into them. We do not have access to this information and therefore we choose an easier,
+        // linked into them. We do not have access to this information and therefore we choose
-        // yet more compute intensive route, of telling solc that all of the files need to link the
+        // an easier, yet more compute intensive route, of telling solc that all of the files
-        // library and it will only perform the linking for the files that do actually need the
+        // need to link the library and it will only perform the linking for the files that do
-        // library.
+        // actually need the library.
         compiler = FilesWithExtensionIterator::new(metadata.directory()?)
             .with_allowed_extension("sol")
             .fold(compiler, |compiler, path| {
@@ -727,7 +646,6 @@ async fn compile_corpus(
                 TestingPlatform::Geth => {
                     let _ = compile_contracts::<Geth>(
                         &metadata.content,
-                        &metadata.path,
                         &mode,
                         config,
                         &Default::default(),
@@ -737,7 +655,6 @@ async fn compile_corpus(
                 TestingPlatform::Kitchensink => {
                     let _ = compile_contracts::<Geth>(
                         &metadata.content,
-                        &metadata.path,
                         &mode,
                         config,
                         &Default::default(),

crates/format/Cargo.toml

@@ -16,13 +16,9 @@ alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
 tracing = { workspace = true }
-regex = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 
-revive-common = { workspace = true }
-
 [dev-dependencies]
 tokio = { workspace = true }
-indoc = { workspace = true }

crates/format/src/case.rs

@@ -15,7 +15,6 @@ pub struct Case {
     pub inputs: Vec<Input>,
     pub group: Option<String>,
     pub expected: Option<Expected>,
-    pub ignore: Option<bool>,
 }
 
 impl Case {

crates/format/src/input.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use alloy::{
     eips::BlockNumberOrTag,
     hex::ToHexExt,
+    json_abi::JsonAbi,
     network::TransactionBuilder,
     primitives::{Address, Bytes, U256},
     rpc::types::TransactionRequest,
@@ -14,8 +15,8 @@ use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
 
+use crate::metadata::ContractInstance;
 use crate::traits::ResolverApi;
-use crate::{metadata::ContractInstance, traits::ResolutionContext};
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
@@ -186,21 +187,37 @@ impl Input {
         ContractInstance::new("Test")
     }
 
-    pub async fn encoded_input(
+    fn instance_to_address(
         &self,
-        resolver: &impl ResolverApi,
+        instance: &ContractInstance,
-        context: ResolutionContext<'_>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+    ) -> anyhow::Result<Address> {
+        deployed_contracts
+            .get(instance)
+            .map(|(a, _)| *a)
+            .ok_or_else(|| anyhow::anyhow!("instance {instance:?} not deployed"))
+    }
+
+    pub async fn encoded_input<'a>(
+        &'a self,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<Bytes> {
         match self.method {
             Method::Deployer | Method::Fallback => {
-                let calldata = self.calldata.calldata(resolver, context).await?;
+                let calldata = self
+                    .calldata
+                    .calldata(deployed_contracts, variables, chain_state_provider)
+                    .await?;
 
                 Ok(calldata.into())
             }
             Method::FunctionName(ref function_name) => {
-                let Some(abi) = context.deployed_contract_abi(&self.instance) else {
+                let Some(abi) = deployed_contracts.get(&self.instance).map(|(_, a)| a) else {
                     tracing::error!(
                         contract_name = self.instance.as_ref(),
+                        available_abis = ?deployed_contracts.keys().collect::<Vec<_>>(),
                         "Attempted to lookup ABI of contract but it wasn't found"
                     );
                     anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
@@ -239,7 +256,12 @@ impl Input {
                 let mut calldata = Vec::<u8>::with_capacity(4 + self.calldata.size_requirement());
                 calldata.extend(function.selector().0);
                 self.calldata
-                    .calldata_into_slice(&mut calldata, resolver, context)
+                    .calldata_into_slice(
+                        &mut calldata,
+                        deployed_contracts,
+                        variables,
+                        chain_state_provider,
+                    )
                     .await?;
 
                 Ok(calldata.into())
@@ -248,12 +270,15 @@ impl Input {
     }
 
     /// Parse this input into a legacy transaction.
-    pub async fn legacy_transaction(
+    pub async fn legacy_transaction<'a>(
-        &self,
+        &'a self,
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self.encoded_input(resolver, context).await?;
+        let input_data = self
+            .encoded_input(deployed_contracts, variables, chain_state_provider)
+            .await?;
         let transaction_request = TransactionRequest::default().from(self.caller).value(
             self.value
                 .map(|value| value.into_inner())
@@ -262,10 +287,7 @@ impl Input {
         match self.method {
             Method::Deployer => Ok(transaction_request.with_deploy_code(input_data)),
             _ => Ok(transaction_request
-                .to(context
+                .to(self.instance_to_address(&self.instance, deployed_contracts)?)
-                    .deployed_contract_address(&self.instance)
-                    .context("Failed to get the contract address")
-                    .copied()?)
                 .input(input_data.into())),
         }
     }
@@ -334,22 +356,29 @@ impl Calldata {
         }
     }
 
-    pub async fn calldata(
+    pub async fn calldata<'a>(
-        &self,
+        &'a self,
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<Vec<u8>> {
         let mut buffer = Vec::<u8>::with_capacity(self.size_requirement());
-        self.calldata_into_slice(&mut buffer, resolver, context)
+        self.calldata_into_slice(
+            &mut buffer,
+            deployed_contracts,
+            variables,
+            chain_state_provider,
+        )
         .await?;
         Ok(buffer)
     }
 
-    pub async fn calldata_into_slice(
+    pub async fn calldata_into_slice<'a>(
-        &self,
+        &'a self,
         buffer: &mut Vec<u8>,
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<()> {
         match self {
             Calldata::Single(bytes) => {
@@ -357,7 +386,10 @@ impl Calldata {
             }
             Calldata::Compound(items) => {
                 for (arg_idx, arg) in items.iter().enumerate() {
-                    match arg.resolve(resolver, context).await {
+                    match arg
+                        .resolve(deployed_contracts, variables.clone(), chain_state_provider)
+                        .await
+                    {
                         Ok(resolved) => {
                             buffer.extend(resolved.to_be_bytes::<32>());
                         }
@@ -380,11 +412,12 @@ impl Calldata {
     }
 
     /// Checks if this [`Calldata`] is equivalent to the passed calldata bytes.
-    pub async fn is_equivalent(
+    pub async fn is_equivalent<'a>(
-        &self,
+        &'a self,
         other: &[u8],
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<bool> {
         match self {
             Calldata::Single(calldata) => Ok(calldata == other),
@@ -406,7 +439,9 @@ impl Calldata {
                         std::borrow::Cow::Borrowed(other)
                     };
 
-                    let this = this.resolve(resolver, context).await?;
+                    let this = this
+                        .resolve(deployed_contracts, variables.clone(), chain_state_provider)
+                        .await?;
                     let other = U256::from_be_slice(&other);
                     if this != other {
                         return Ok(false);
@@ -419,16 +454,17 @@ impl Calldata {
 }
 
 impl CalldataItem {
-    async fn resolve(
+    async fn resolve<'a>(
-        &self,
+        &'a self,
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<U256> {
         let mut stack = Vec::<CalldataToken<U256>>::new();
 
         for token in self
             .calldata_tokens()
-            .map(|token| token.resolve(resolver, context))
+            .map(|token| token.resolve(deployed_contracts, variables.clone(), chain_state_provider))
         {
             let token = token.await?;
             let new_token = match token {
@@ -483,7 +519,7 @@ impl CalldataItem {
         }
     }
 
-    fn calldata_tokens(&self) -> impl Iterator<Item = CalldataToken<&str>> {
+    fn calldata_tokens<'a>(&'a self) -> impl Iterator<Item = CalldataToken<&'a str>> + 'a {
         self.0.split(' ').map(|item| match item {
             "+" => CalldataToken::Operation(Operation::Addition),
             "-" => CalldataToken::Operation(Operation::Subtraction),
@@ -507,11 +543,9 @@ impl<T> CalldataToken<T> {
     const GAS_LIMIT_VARIABLE: &str = "$GAS_LIMIT";
     const COINBASE_VARIABLE: &str = "$COINBASE";
     const DIFFICULTY_VARIABLE: &str = "$DIFFICULTY";
-    const BLOCK_BASE_FEE_VARIABLE: &str = "$BASE_FEE";
     const BLOCK_HASH_VARIABLE_PREFIX: &str = "$BLOCK_HASH";
     const BLOCK_NUMBER_VARIABLE: &str = "$BLOCK_NUMBER";
     const BLOCK_TIMESTAMP_VARIABLE: &str = "$BLOCK_TIMESTAMP";
-    const TRANSACTION_GAS_PRICE: &str = "$TRANSACTION_GAS_PRICE";
     const VARIABLE_PREFIX: &str = "$VARIABLE:";
 
     fn into_item(self) -> Option<T> {
@@ -531,21 +565,24 @@ impl<T: AsRef<str>> CalldataToken<T> {
     /// This piece of code is taken from the matter-labs-tester repository which is licensed under
     /// MIT or Apache. The original source code can be found here:
     /// https://github.com/matter-labs/era-compiler-tester/blob/0ed598a27f6eceee7008deab3ff2311075a2ec69/compiler_tester/src/test/case/input/value.rs#L43-L146
-    async fn resolve(
+    async fn resolve<'a>(
         self,
-        resolver: &impl ResolverApi,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        context: ResolutionContext<'_>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<CalldataToken<U256>> {
         match self {
             Self::Item(item) => {
                 let item = item.as_ref();
                 let value = if let Some(instance) = item.strip_suffix(Self::ADDRESS_VARIABLE_SUFFIX)
                 {
-                    context
+                    Ok(U256::from_be_slice(
-                        .deployed_contract_address(&ContractInstance::new(instance))
+                        deployed_contracts
-                        .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))
+                            .get(&ContractInstance::new(instance))
-                        .map(AsRef::as_ref)
+                            .map(|(a, _)| *a)
-                        .map(U256::from_be_slice)
+                            .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
+                            .as_ref(),
+                    ))
                 } else if let Some(value) = item.strip_prefix(Self::NEGATIVE_VALUE_PREFIX) {
                     let value = U256::from_str_radix(value, 10).map_err(|error| {
                         anyhow::anyhow!("Invalid decimal literal after `-`: {}", error)
@@ -558,36 +595,27 @@ impl<T: AsRef<str>> CalldataToken<T> {
                         .ok_or_else(|| anyhow::anyhow!("`-0` is invalid literal"))?;
                     Ok(U256::MAX.checked_sub(value).expect("Always valid"))
                 } else if let Some(value) = item.strip_prefix(Self::HEX_LITERAL_PREFIX) {
-                    U256::from_str_radix(value, 16)
+                    Ok(U256::from_str_radix(value, 16).map_err(|error| {
-                        .map_err(|error| anyhow::anyhow!("Invalid hexadecimal literal: {}", error))
+                        anyhow::anyhow!("Invalid hexadecimal literal: {}", error)
+                    })?)
                 } else if item == Self::CHAIN_VARIABLE {
-                    resolver.chain_id().await.map(U256::from)
+                    let chain_id = chain_state_provider.chain_id().await?;
-                } else if item == Self::TRANSACTION_GAS_PRICE {
+                    Ok(U256::from(chain_id))
-                    context
-                        .transaction_hash()
-                        .context("No transaction hash provided to get the transaction gas price")
-                        .map(|tx_hash| resolver.transaction_gas_price(tx_hash))?
-                        .await
-                        .map(U256::from)
                 } else if item == Self::GAS_LIMIT_VARIABLE {
-                    resolver
+                    let gas_limit = chain_state_provider
-                        .block_gas_limit(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .block_gas_limit(BlockNumberOrTag::Latest)
-                        .await
+                        .await?;
-                        .map(U256::from)
+                    Ok(U256::from(gas_limit))
                 } else if item == Self::COINBASE_VARIABLE {
-                    resolver
+                    let coinbase = chain_state_provider
-                        .block_coinbase(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .block_coinbase(BlockNumberOrTag::Latest)
-                        .await
+                        .await?;
-                        .map(|address| U256::from_be_slice(address.as_ref()))
+                    Ok(U256::from_be_slice(coinbase.as_ref()))
                 } else if item == Self::DIFFICULTY_VARIABLE {
-                    resolver
+                    let block_difficulty = chain_state_provider
-                        .block_difficulty(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .block_difficulty(BlockNumberOrTag::Latest)
-                        .await
+                        .await?;
-                } else if item == Self::BLOCK_BASE_FEE_VARIABLE {
+                    Ok(block_difficulty)
-                    resolver
-                        .block_base_fee(context.resolve_block_number(BlockNumberOrTag::Latest))
-                        .await
-                        .map(U256::from)
                 } else if item.starts_with(Self::BLOCK_HASH_VARIABLE_PREFIX) {
                     let offset: u64 = item
                         .split(':')
@@ -595,34 +623,35 @@ impl<T: AsRef<str>> CalldataToken<T> {
                         .and_then(|value| value.parse().ok())
                         .unwrap_or_default();
 
-                    let current_block_number = match context.tip_block_number() {
+                    let current_block_number = chain_state_provider.last_block_number().await?;
-                        Some(block_number) => *block_number,
+                    let desired_block_number = current_block_number - offset;
-                        None => resolver.last_block_number().await?,
-                    };
-                    let desired_block_number = current_block_number.saturating_sub(offset);
 
-                    let block_hash = resolver.block_hash(desired_block_number.into()).await?;
+                    let block_hash = chain_state_provider
+                        .block_hash(desired_block_number.into())
+                        .await?;
 
                     Ok(U256::from_be_bytes(block_hash.0))
                 } else if item == Self::BLOCK_NUMBER_VARIABLE {
-                    let current_block_number = match context.tip_block_number() {
+                    let current_block_number = chain_state_provider.last_block_number().await?;
-                        Some(block_number) => *block_number,
-                        None => resolver.last_block_number().await?,
-                    };
                     Ok(U256::from(current_block_number))
                 } else if item == Self::BLOCK_TIMESTAMP_VARIABLE {
-                    resolver
+                    let timestamp = chain_state_provider
-                        .block_timestamp(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .block_timestamp(BlockNumberOrTag::Latest)
-                        .await
+                        .await?;
-                        .map(U256::from)
+                    Ok(U256::from(timestamp))
                 } else if let Some(variable_name) = item.strip_prefix(Self::VARIABLE_PREFIX) {
-                    context
+                    let Some(variables) = variables.into() else {
-                        .variable(variable_name)
+                        anyhow::bail!(
-                        .context("Variable lookup failed")
+                            "Variable resolution required but no variables were passed in"
-                        .copied()
+                        );
+                    };
+                    let Some(variable) = variables.get(variable_name) else {
+                        anyhow::bail!("No variable found with the name {}", variable_name)
+                    };
+                    Ok(*variable)
                 } else {
-                    U256::from_str_radix(item, 10)
+                    Ok(U256::from_str_radix(item, 10)
-                        .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))
+                        .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))?)
                 };
                 value.map(CalldataToken::Item)
             }
@@ -661,49 +690,50 @@ impl<'de> Deserialize<'de> for EtherValue {
 mod tests {
 
     use super::*;
-    use alloy::{eips::BlockNumberOrTag, json_abi::JsonAbi};
+    use alloy::json_abi::JsonAbi;
-    use alloy_primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address};
+    use alloy_primitives::address;
     use alloy_sol_types::SolValue;
     use std::collections::HashMap;
 
     struct MockResolver;
 
     impl ResolverApi for MockResolver {
-        async fn chain_id(&self) -> anyhow::Result<ChainId> {
+        async fn chain_id(&self) -> anyhow::Result<alloy_primitives::ChainId> {
             Ok(0x123)
         }
 
-        async fn block_gas_limit(&self, _: BlockNumberOrTag) -> anyhow::Result<u128> {
+        async fn block_gas_limit(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<u128> {
             Ok(0x1234)
         }
 
-        async fn block_coinbase(&self, _: BlockNumberOrTag) -> anyhow::Result<Address> {
+        async fn block_coinbase(
+            &self,
+            _: alloy::eips::BlockNumberOrTag,
+        ) -> anyhow::Result<Address> {
             Ok(Address::ZERO)
         }
 
-        async fn block_difficulty(&self, _: BlockNumberOrTag) -> anyhow::Result<U256> {
+        async fn block_difficulty(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<U256> {
             Ok(U256::from(0x12345u128))
         }
 
-        async fn block_base_fee(&self, _: BlockNumberOrTag) -> anyhow::Result<u64> {
+        async fn block_hash(
-            Ok(0x100)
+            &self,
-        }
+            _: alloy::eips::BlockNumberOrTag,
-
+        ) -> anyhow::Result<alloy_primitives::BlockHash> {
-        async fn block_hash(&self, _: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
             Ok([0xEE; 32].into())
         }
 
-        async fn block_timestamp(&self, _: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
+        async fn block_timestamp(
+            &self,
+            _: alloy::eips::BlockNumberOrTag,
+        ) -> anyhow::Result<alloy_primitives::BlockTimestamp> {
             Ok(0x123456)
         }
 
-        async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
+        async fn last_block_number(&self) -> anyhow::Result<alloy_primitives::BlockNumber> {
             Ok(0x1234567)
         }
-
-        async fn transaction_gas_price(&self, _: &TxHash) -> anyhow::Result<u128> {
-            Ok(0x200)
-        }
     }
 
     #[tokio::test]
@@ -742,9 +772,10 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let resolver = MockResolver;
+        let encoded = input
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+            .encoded_input(&contracts, None, &MockResolver)
-        let encoded = input.encoded_input(&resolver, context).await.unwrap();
+            .await
+            .unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (u64,);
@@ -786,9 +817,10 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let resolver = MockResolver;
+        let encoded = input
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+            .encoded_input(&contracts, None, &MockResolver)
-        let encoded = input.encoded_input(&resolver, context).await.unwrap();
+            .await
+            .unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (alloy_primitives::Address,);
@@ -833,9 +865,10 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let resolver = MockResolver;
+        let encoded = input
-        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+            .encoded_input(&contracts, None, &MockResolver)
-        let encoded = input.encoded_input(&resolver, context).await.unwrap();
+            .await
+            .unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (alloy_primitives::Address,);
@@ -849,10 +882,11 @@ mod tests {
     async fn resolve_calldata_item(
         input: &str,
         deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        resolver: &impl ResolverApi,
+        chain_state_provider: &impl ResolverApi,
     ) -> anyhow::Result<U256> {
-        let context = ResolutionContext::new_from_parts(deployed_contracts, None, None, None);
+        CalldataItem::new(input)
-        CalldataItem::new(input).resolve(resolver, context).await
+            .resolve(deployed_contracts, None, chain_state_provider)
+            .await
     }
 
     #[tokio::test]
@@ -930,26 +964,6 @@ mod tests {
         )
     }
 
-    #[tokio::test]
-    async fn resolver_can_resolve_block_base_fee_variable() {
-        // Arrange
-        let input = "$BASE_FEE";
-
-        // Act
-        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver).await;
-
-        // Assert
-        let resolved = resolved.expect("Failed to resolve argument");
-        assert_eq!(
-            resolved,
-            MockResolver
-                .block_base_fee(Default::default())
-                .await
-                .map(U256::from)
-                .unwrap()
-        )
-    }
-
     #[tokio::test]
     async fn resolver_can_resolve_block_hash_variable() {
         // Arrange

crates/format/src/lib.rs

@@ -6,5 +6,3 @@ pub mod input;
 pub mod metadata;
 pub mod mode;
 pub mod traits;
-
-mod semantic_tests;

crates/format/src/metadata.rs

@@ -291,7 +291,7 @@ impl FromStr for ContractPathAndIdent {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut splitted_string = s.split(':').peekable();
+        let mut splitted_string = s.split(":").peekable();
         let mut path = None::<String>;
         let mut identifier = None::<String>;
         loop {
@@ -316,7 +316,7 @@ impl FromStr for ContractPathAndIdent {
                 contract_ident: ContractIdent::new(identifier),
             }),
             (None, Some(path)) | (Some(path), None) => {
-                let Some(identifier) = path.split('.').next().map(ToOwned::to_owned) else {
+                let Some(identifier) = path.split(".").next().map(ToOwned::to_owned) else {
                     anyhow::bail!("Failed to find identifier");
                 };
                 Ok(Self {

crates/format/src/semantic_tests/function_parser.rs

@@ -1,584 +0,0 @@
-use std::io::{Read, Seek};
-
-use anyhow::{Result, anyhow};
-
-use revive_dt_common::define_wrapper_type;
-
-trait ReadExt: Read + Seek {
-    fn read_while(
-        &mut self,
-        buf: &mut Vec<u8>,
-        callback: impl Fn(&u8) -> bool + Clone,
-    ) -> std::io::Result<()> {
-        for byte in self.bytes() {
-            let byte = byte?;
-            let include_byte = callback(&byte);
-            if include_byte {
-                buf.push(byte)
-            } else {
-                self.seek(std::io::SeekFrom::Current(-1))?;
-                break;
-            }
-        }
-        Ok(())
-    }
-
-    fn skip_while(&mut self, callback: impl Fn(&u8) -> bool + Clone) -> std::io::Result<()> {
-        for byte in self.bytes() {
-            let byte = byte?;
-            let skip = callback(&byte);
-            if !skip {
-                self.seek(std::io::SeekFrom::Current(-1))?;
-                break;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<R> ReadExt for R where R: Read + Seek {}
-
-trait Parse: Sized {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self>;
-
-    fn peek(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        let pos = token_stream.stream_position()?;
-        let this = Self::parse(token_stream);
-        token_stream.seek(std::io::SeekFrom::Start(pos))?;
-        this
-    }
-}
-
-macro_rules! impl_parse_for_tuple {
-    ($first_ident: ident $(, $($ident: ident),*)?) => {
-        impl<$first_ident: Parse, $($($ident: Parse),*)?> Parse for ($first_ident, $($($ident),*)?)  {
-            fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-                Ok((
-                    $first_ident::parse(token_stream)?,
-                    $(
-                        $($ident::parse(token_stream)?),*
-                    )?
-                ))
-            }
-        }
-
-        $(impl_parse_for_tuple!( $($ident),* );)?
-    };
-    () => {}
-}
-
-impl_parse_for_tuple!(
-    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z
-);
-
-impl Parse for String {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        let mut buffer = Vec::new();
-        token_stream.read_while(&mut buffer, |char| {
-            char.is_ascii_alphanumeric() || char.is_ascii_whitespace()
-        })?;
-        let string = String::from_utf8(buffer)?;
-        if string.trim().is_empty() {
-            Err(anyhow!("Parsing string resulted in an empty string"))
-        } else {
-            Ok(string.trim().to_owned())
-        }
-    }
-}
-
-impl Parse for u64 {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        token_stream.skip_while(u8::is_ascii_whitespace)?;
-
-        let mut buffer = Vec::new();
-        token_stream.read_while(&mut buffer, |char| matches!(char, b'0'..=b'9'))?;
-        let string = String::from_utf8(buffer)?;
-        string.parse().map_err(Into::into)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct Function {
-    ident: FunctionIdent,
-    arg_types: Parenthesized<FunctionArgumentType, ','>,
-    colon: ColonToken,
-    function_arguments: Vec<FunctionArgument>,
-    arrow_token: ArrowToken,
-    function_returns: Vec<FunctionReturn>,
-    functions_options: Vec<PostFunctionOptions>,
-}
-
-impl Parse for Function {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            ident: Parse::parse(token_stream)?,
-            arg_types: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            function_arguments: {
-                let mut arguments = Vec::default();
-                loop {
-                    if arguments.is_empty() {
-                        if FunctionArgument::peek(token_stream).is_ok() {
-                            arguments.push(FunctionArgument::parse(token_stream)?);
-                        }
-                    } else {
-                        if CommaToken::peek(token_stream).is_ok() {
-                            CommaToken::parse(token_stream)?;
-                            arguments.push(FunctionArgument::parse(token_stream)?);
-                        } else {
-                            break;
-                        }
-                    }
-                }
-                arguments
-            },
-            arrow_token: Parse::parse(token_stream)?,
-            function_returns: {
-                let mut returns = Vec::default();
-
-                loop {
-                    if returns.is_empty() || CommaToken::peek(token_stream).is_ok() {
-                        if !returns.is_empty() {
-                            CommaToken::parse(token_stream)?;
-                        }
-
-                        let mut buf = Vec::new();
-                        token_stream
-                            .read_while(&mut buf, |byte| *byte != b'\n' && *byte != b',')?;
-                        if NewLineToken::peek(token_stream).is_ok() {
-                            NewLineToken::parse(token_stream)?;
-                        } else if CommaToken::peek(token_stream).is_ok() {
-                            CommaToken::peek(token_stream)?;
-                        }
-                        let string = String::from_utf8(buf)?;
-                        let trimmed = string.trim();
-                        if trimmed.chars().all(|char| char.is_whitespace()) {
-                            break;
-                        } else {
-                            returns.push(FunctionReturn(trimmed.to_string()));
-                        }
-                    } else {
-                        break;
-                    }
-                }
-
-                returns
-            },
-            functions_options: {
-                let mut options = Vec::default();
-
-                while PostFunctionOptions::peek(token_stream).is_ok() {
-                    options.push(PostFunctionOptions::parse(token_stream)?)
-                }
-
-                options
-            },
-        })
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct Parenthesized<T, const SEP: char>(pub Vec<T>);
-
-impl<T, const SEP: char> Parse for Parenthesized<T, SEP>
-where
-    T: Parse,
-{
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        OpenParenToken::parse(token_stream)?;
-
-        let mut inner = Vec::new();
-        loop {
-            if CloseParenToken::peek(token_stream).is_ok() {
-                break;
-            }
-            inner.push(T::parse(token_stream)?);
-
-            let reached_the_end = CloseParenToken::peek(token_stream).is_ok();
-            if reached_the_end {
-                break;
-            } else {
-                SingleCharToken::<SEP>::parse(token_stream)?;
-            }
-        }
-
-        CloseParenToken::parse(token_stream)?;
-
-        Ok(Self(inner))
-    }
-}
-
-define_wrapper_type!(
-    /// A wrapper type for a function identifier token.
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    struct FunctionIdent(String);
-);
-
-impl Parse for FunctionIdent {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Parse::parse(token_stream).map(Self)
-    }
-}
-
-define_wrapper_type!(
-    /// A wrapper type for a function argument token.
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    struct FunctionArgumentType(String);
-);
-
-impl Parse for FunctionArgumentType {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Parse::parse(token_stream).map(Self)
-    }
-}
-
-define_wrapper_type!(
-    /// A wrapper type for a function argument token.
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    struct FunctionArgument(String);
-);
-
-impl Parse for FunctionArgument {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Parse::parse(token_stream).map(Self)
-    }
-}
-
-define_wrapper_type!(
-    /// A wrapper type for a function return token.
-    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    struct FunctionReturn(String);
-);
-
-impl Parse for FunctionReturn {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Parse::parse(token_stream).map(Self)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct SingleCharToken<const CHAR: char>;
-
-impl<const CHAR: char> Parse for SingleCharToken<CHAR> {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        let mut buf = [0; 1];
-        loop {
-            token_stream.read(&mut buf)?;
-            let [byte] = buf;
-            if byte == CHAR as u8 {
-                return Ok(Self);
-            } else if byte.is_ascii_whitespace() {
-                continue;
-            } else {
-                return Err(anyhow!(
-                    "Invalid character encountered {} expected {}",
-                    byte as char,
-                    CHAR
-                ));
-            }
-        }
-    }
-}
-
-// Bit of a hack, but I do this because Rust analyzer doesn't like `SingleCharToken<'>'>` and it
-// messes up with the syntax highlighting.
-const GT_CHAR: char = '>';
-
-type ColonToken = SingleCharToken<':'>;
-type CommaToken = SingleCharToken<','>;
-type OpenParenToken = SingleCharToken<'('>;
-type CloseParenToken = SingleCharToken<')'>;
-type DashToken = SingleCharToken<'-'>;
-type GtToken = SingleCharToken<{ GT_CHAR }>;
-type NewLineToken = SingleCharToken<'\n'>;
-type SpaceToken = SingleCharToken<' '>;
-type ArrowToken = (DashToken, GtToken);
-
-macro_rules! string_literal_token {
-    (
-        $($ty_ident: ident => $str: expr),* $(,)?
-    ) => {
-        $(
-            #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-            pub struct $ty_ident;
-
-            impl Parse for $ty_ident {
-                fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-                    token_stream.skip_while(u8::is_ascii_whitespace)?;
-
-                    let mut buffer = [0; $str.len()];
-                    token_stream.read(&mut buffer)?;
-                    while SpaceToken::peek(token_stream).is_ok() {
-                        SpaceToken::parse(token_stream)?;
-                    }
-                    if $str.as_bytes() == buffer {
-                        Ok(Self)
-                    } else {
-                        Err(anyhow!("Invalid string - expected {} but got {:?}", $str, str::from_utf8(&buffer)))
-                    }
-                }
-            }
-        )*
-    };
-}
-string_literal_token! {
-    GasLiteralStringToken => "gas",
-    IrOptimizedLiteralStringToken => "irOptimized",
-    LegacyLiteralStringToken => "legacy",
-    LegacyOptimizedLiteralStringToken => "legacyOptimized",
-    CodeLiteralStringToken => "code",
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum PostFunctionOptions {
-    IrOptimizedGasOption(IrOptimizedGasOption),
-    IrOptimizedGasCodeOption(IrOptimizedGasCodeOption),
-    LegacyGasOption(LegacyGasOption),
-    LegacyGasCodeOption(LegacyGasCodeOption),
-    LegacyOptimizedGasOption(LegacyOptimizedGasOption),
-    LegacyOptimizedGasCodeOption(LegacyOptimizedGasCodeOption),
-}
-
-impl Parse for PostFunctionOptions {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        if IrOptimizedGasOption::peek(token_stream).is_ok() {
-            IrOptimizedGasOption::parse(token_stream).map(Self::IrOptimizedGasOption)
-        } else if IrOptimizedGasCodeOption::peek(token_stream).is_ok() {
-            IrOptimizedGasCodeOption::parse(token_stream).map(Self::IrOptimizedGasCodeOption)
-        } else if LegacyGasOption::peek(token_stream).is_ok() {
-            LegacyGasOption::parse(token_stream).map(Self::LegacyGasOption)
-        } else if LegacyGasCodeOption::peek(token_stream).is_ok() {
-            LegacyGasCodeOption::parse(token_stream).map(Self::LegacyGasCodeOption)
-        } else if LegacyOptimizedGasOption::peek(token_stream).is_ok() {
-            LegacyOptimizedGasOption::parse(token_stream).map(Self::LegacyOptimizedGasOption)
-        } else if LegacyOptimizedGasCodeOption::peek(token_stream).is_ok() {
-            LegacyOptimizedGasCodeOption::parse(token_stream)
-                .map(Self::LegacyOptimizedGasCodeOption)
-        } else {
-            Err(anyhow!("Failed to parse post function options"))
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct IrOptimizedGasOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: IrOptimizedLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for IrOptimizedGasOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct IrOptimizedGasCodeOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: IrOptimizedLiteralStringToken,
-    pub code: CodeLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for IrOptimizedGasCodeOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            code: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct LegacyGasOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: LegacyLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for LegacyGasOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct LegacyGasCodeOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: LegacyLiteralStringToken,
-    pub code: CodeLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for LegacyGasCodeOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            code: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct LegacyOptimizedGasOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: LegacyOptimizedLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for LegacyOptimizedGasOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-struct LegacyOptimizedGasCodeOption {
-    pub gas_token: GasLiteralStringToken,
-    pub gas_option: LegacyOptimizedLiteralStringToken,
-    pub code: CodeLiteralStringToken,
-    pub colon: ColonToken,
-    pub value: u64,
-}
-
-impl Parse for LegacyOptimizedGasCodeOption {
-    fn parse(token_stream: &mut (impl Read + Seek)) -> Result<Self> {
-        Ok(Self {
-            gas_token: Parse::parse(token_stream)?,
-            gas_option: Parse::parse(token_stream)?,
-            code: Parse::parse(token_stream)?,
-            colon: Parse::parse(token_stream)?,
-            value: Parse::parse(token_stream)?,
-        })
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::io::Cursor;
-
-    use indoc::indoc;
-
-    use super::*;
-
-    #[test]
-    fn complex_function_can_be_parsed() {
-        // Arrange
-        let string = indoc!(
-            r#"
-            myFunction(uint256, uint64,
-            )
-            :
-            1, 2
-            , 3
-            -> 1, 2, 3, 4
-            gas irOptimized: 135499
-            gas legacy: 137095
-            gas legacyOptimized: 135823
-            gas irOptimized code: 135499
-            gas legacy code: 137095
-            gas legacyOptimized code: 135823
-            "#
-        );
-        let mut token_stream = Cursor::new(string);
-
-        // Act
-        let function = Function::parse(&mut token_stream);
-
-        // Assert
-        let function = function.expect("Function parsing failed");
-        assert_eq!(
-            function,
-            Function {
-                ident: FunctionIdent::new("myFunction"),
-                arg_types: Parenthesized(vec![
-                    FunctionArgumentType::new("uint256"),
-                    FunctionArgumentType::new("uint64")
-                ]),
-                colon: ColonToken::default(),
-                function_arguments: vec![
-                    FunctionArgument::new("1"),
-                    FunctionArgument::new("2"),
-                    FunctionArgument::new("3")
-                ],
-                arrow_token: ArrowToken::default(),
-                function_returns: vec![
-                    FunctionReturn::new("1"),
-                    FunctionReturn::new("2"),
-                    FunctionReturn::new("3"),
-                    FunctionReturn::new("4"),
-                ],
-                functions_options: vec![
-                    PostFunctionOptions::IrOptimizedGasOption(IrOptimizedGasOption {
-                        gas_token: Default::default(),
-                        gas_option: Default::default(),
-                        colon: Default::default(),
-                        value: 135499
-                    }),
-                    PostFunctionOptions::LegacyGasOption(LegacyGasOption {
-                        gas_token: Default::default(),
-                        gas_option: Default::default(),
-                        colon: Default::default(),
-                        value: 137095
-                    }),
-                    PostFunctionOptions::LegacyOptimizedGasOption(LegacyOptimizedGasOption {
-                        gas_token: Default::default(),
-                        gas_option: Default::default(),
-                        colon: Default::default(),
-                        value: 135823
-                    }),
-                    PostFunctionOptions::IrOptimizedGasCodeOption(IrOptimizedGasCodeOption {
-                        gas_token: Default::default(),
-                        gas_option: Default::default(),
-                        code: Default::default(),
-                        colon: Default::default(),
-                        value: 135499
-                    }),
-                    PostFunctionOptions::LegacyGasCodeOption(LegacyGasCodeOption {
-                        gas_token: Default::default(),
-                        gas_option: Default::default(),
-                        code: Default::default(),
-                        colon: Default::default(),
-                        value: 137095
-                    }),
-                    PostFunctionOptions::LegacyOptimizedGasCodeOption(
-                        LegacyOptimizedGasCodeOption {
-                            gas_token: Default::default(),
-                            gas_option: Default::default(),
-                            code: Default::default(),
-                            colon: Default::default(),
-                            value: 135823
-                        }
-                    ),
-                ]
-            }
-        );
-    }
-}

crates/format/src/semantic_tests/mod.rs

@@ -1,12 +0,0 @@
-//! This module contains a parser for the Solidity semantic tests allowing them to be parsed into
-//! regular [`Metadata`] objects that can be executed by the testing framework.
-//!
-//! [`Metadata`]: crate::metadata::Metadata
-
-mod function_parser;
-mod sections;
-mod test_configuration;
-
-pub use function_parser::*;
-pub use sections::*;
-pub use test_configuration::*;

crates/format/src/semantic_tests/sections.rs

@@ -1,338 +0,0 @@
-use std::{collections::VecDeque, path::PathBuf, sync::LazyLock};
-
-use anyhow::{Context, Result, anyhow};
-use regex::Regex;
-
-use crate::semantic_tests::TestConfiguration;
-
-/// This enum describes the various sections that a semantic test can contain.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum SemanticTestSection {
-    /// A source code section that consists of Solidity code.
-    ///
-    /// Source code sections might have a file name and they might not. Take the following section
-    /// as an example which doesn't contain a filename
-    ///
-    /// ```solidity
-    /// contract C {
-    ///     bytes data;
-    ///     function () pure returns (bytes memory) f;
-    ///     constructor() {
-    ///         data = M.longdata();
-    ///         f = M.longdata;
-    ///     }
-    ///     function test() public view returns (bool) {
-    ///         return keccak256(data) == keccak256(f());
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The above will translate into this enum variant and without a defined filename for the code.
-    /// However, the following will translate into this variant of the enum with a defined file name
-    ///
-    /// ```solidity
-    /// ==== Source: main.sol ====
-    /// contract C {
-    ///     bytes data;
-    ///     function () pure returns (bytes memory) f;
-    ///     constructor() {
-    ///         data = M.longdata();
-    ///         f = M.longdata;
-    ///     }
-    ///     function test() public view returns (bool) {
-    ///         return keccak256(data) == keccak256(f());
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// This is because of the use of the `Source` directive at the start of the section.
-    ///
-    /// Note the following: All tests will be run on the last declared contract in the semantic test
-    /// and therefore the order of the contracts matters.
-    SourceCode {
-        file_name: Option<PathBuf>,
-        content: String,
-    },
-
-    /// An external source section from the solidity semantic tests.
-    ///
-    /// External source sections from the solidity semantic tests are the simplest sections out of
-    /// them all. They look like the following:
-    ///
-    /// ```solidity
-    /// ==== ExternalSource: _prbmath/PRBMathSD59x18.sol ====
-    /// ```
-    ///
-    /// And they can be thought of as a directive to the compiler to include these contracts when
-    /// compiling the test contract.
-    ExternalSource { path: PathBuf },
-
-    /// A test configuration section
-    ///
-    /// This section contains various configuration and filters that are used for the tests and its
-    /// always the section that comes right before the actual tests. This section looks like the
-    /// following:
-    ///
-    /// ```solidity
-    /// // ====
-    /// // ABIEncoderV1Only: true
-    /// // compileViaYul: false
-    /// // ----
-    /// ```
-    TestConfiguration { configuration: TestConfiguration },
-
-    /// A test inputs section.
-    ///
-    /// This section consists of all of the lines that make up the test inputs or the test steps
-    /// which is the final section found in the semantic test files. This section looks like the
-    /// following:
-    ///
-    /// ```solidity
-    /// // ----
-    /// // f1() -> 0x20, 0x40, 0x20, 0
-    /// // f2(string): 0x20, 0 -> 0x20, 0x40, 0x20, 0
-    /// // f2(string): 0x20, 0, 0 -> 0x20, 0x40, 0x20, 0
-    /// // g1() -> 32, 0
-    /// // g2(string): 0x20, 0 -> 0x20, 0
-    /// // g2(string): 0x20, 0, 0 -> 0x20, 0
-    /// ```
-    TestInputs { lines: Vec<String> },
-}
-
-impl SemanticTestSection {
-    const SOURCE_SECTION_MARKER: &str = "==== Source:";
-    const EXTERNAL_SOURCE_SECTION_MARKER: &str = "==== ExternalSource:";
-    const TEST_CONFIGURATION_SECTION_MARKER: &str = "// ====";
-    const TEST_INPUTS_SECTION_MARKER: &str = "// ----";
-
-    pub fn parse_source_into_sections(source: impl AsRef<str>) -> Result<Vec<Self>> {
-        let mut sections = VecDeque::<Self>::new();
-        sections.push_back(Self::SourceCode {
-            file_name: None,
-            content: Default::default(),
-        });
-
-        for line in source.as_ref().split('\n') {
-            if let Some(new_section) = sections
-                .back_mut()
-                .expect("Impossible case - we have at least one item in the sections")
-                .append_line(line)?
-            {
-                sections.push_back(new_section);
-            }
-        }
-
-        let first_section = sections
-            .front()
-            .expect("Impossible case - there's always at least one section");
-        let remove_first_section = match first_section {
-            SemanticTestSection::SourceCode { file_name, content } => {
-                file_name.is_none() && content.is_empty()
-            }
-            SemanticTestSection::ExternalSource { .. }
-            | SemanticTestSection::TestConfiguration { .. }
-            | SemanticTestSection::TestInputs { .. } => false,
-        };
-        if remove_first_section {
-            sections.pop_front();
-        }
-
-        Ok(sections.into_iter().collect())
-    }
-
-    /// Appends a line to a semantic test section.
-    ///
-    /// This method takes in the current section and a new line and attempts to append it to parse
-    /// it and append it to the current section. If the line is found to be the start of a new
-    /// section then no changes will be made to the current section and instead the line will be
-    /// interpreted according to the rules of new sections.
-    pub fn append_line(&mut self, line: impl AsRef<str>) -> Result<Option<Self>> {
-        static COMMENT_REPLACEMENT_REGEX: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new("#.*#$").unwrap());
-
-        let line = line.as_ref();
-        if line.is_empty() {
-            Ok(None)
-        } else if let Some(source_path) = line.strip_prefix(Self::SOURCE_SECTION_MARKER) {
-            let source_code_file_path = source_path
-                .trim()
-                .split(' ')
-                .next()
-                .context("Failed to find the source code file path")?;
-            Ok(Some(Self::SourceCode {
-                file_name: Some(PathBuf::from(source_code_file_path)),
-                content: Default::default(),
-            }))
-        } else if let Some(external_source_path) =
-            line.strip_prefix(Self::EXTERNAL_SOURCE_SECTION_MARKER)
-        {
-            let source_code_file_path = external_source_path
-                .trim()
-                .split(' ')
-                .next()
-                .context("Failed to find the source code file path")?;
-            Ok(Some(Self::ExternalSource {
-                path: PathBuf::from(source_code_file_path),
-            }))
-        } else if line == Self::TEST_CONFIGURATION_SECTION_MARKER {
-            Ok(Some(Self::TestConfiguration {
-                configuration: Default::default(),
-            }))
-        } else if line == Self::TEST_INPUTS_SECTION_MARKER {
-            Ok(Some(Self::TestInputs {
-                lines: Default::default(),
-            }))
-        } else {
-            match self {
-                SemanticTestSection::SourceCode { content, .. } => {
-                    content.push('\n');
-                    content.push_str(line);
-                    Ok(None)
-                }
-                SemanticTestSection::ExternalSource { .. } => Ok(Some(Self::SourceCode {
-                    file_name: None,
-                    content: line.to_owned(),
-                })),
-                SemanticTestSection::TestConfiguration { configuration } => {
-                    let line = line
-                        .strip_prefix("//")
-                        .with_context(|| {
-                            format!("Line doesn't contain test configuration prefix: {line}")
-                        })?
-                        .trim();
-                    let mut splitted = line.split(':');
-                    let key = splitted.next().context("Failed to find the key")?.trim();
-                    let value = splitted.next().context("Failed to find the value")?.trim();
-                    configuration.with_config(key, value)?;
-                    Ok(None)
-                }
-                SemanticTestSection::TestInputs { lines } => {
-                    let line = line
-                        .strip_prefix("//")
-                        .ok_or_else(|| anyhow!("Line doesn't contain test input prefix: {line}"))
-                        .map(str::trim)?;
-                    let line = COMMENT_REPLACEMENT_REGEX.replace_all(line, "");
-                    if !line.starts_with('#') && !line.chars().all(|char| char.is_whitespace()) {
-                        lines.push(line.to_string());
-                    }
-                    Ok(None)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use indoc::indoc;
-
-    use super::*;
-
-    #[test]
-    fn parses_a_simple_file_correctly() {
-        // Arrange
-        const SIMPLE_FILE: &str = indoc!(
-            r#"
-            ==== Source: main.sol ====
-            contract C {
-                function f() public pure returns (uint) {
-                    return 1;
-                }
-            }
-            // ====
-            // compileViaYul: true
-            // ----
-            // f() -> 1
-            "#
-        );
-
-        // Act
-        let sections =
-            SemanticTestSection::parse_source_into_sections(SIMPLE_FILE).expect("Failed to parse");
-
-        // Assert
-        assert_eq!(
-            sections,
-            vec![
-                SemanticTestSection::SourceCode {
-                    file_name: Some("main.sol".into()),
-                    content: "\ncontract C {\n    function f() public pure returns (uint) {\n        return 1;\n    }\n}".to_string()
-                },
-                SemanticTestSection::TestConfiguration {
-                    configuration: TestConfiguration { compile_via_yul: Some(true.into()), ..Default::default() },
-                },
-                SemanticTestSection::TestInputs {
-                    lines: vec!["f() -> 1".to_string()]
-                }
-            ]
-        )
-    }
-
-    #[test]
-    fn parses_a_complex_file_correctly() {
-        // Arrange
-        const COMPLEX_FILE: &str = indoc!(
-            r#"
-            ==== Source: main.sol ====
-            import "./lib.sol";
-            contract C {
-                function f() public pure returns (uint) {
-                    return Lib.f();
-                }
-            }
-            ==== Source: lib.sol ====
-            library Lib {
-                function f() internal pure returns (uint) {
-                    return 1;
-                }
-            }
-            // ====
-            // compileViaYul: true
-            // ----
-            // # This is a comment
-            // f() -> 1
-            "#
-        );
-
-        // Act
-        let sections =
-            SemanticTestSection::parse_source_into_sections(COMPLEX_FILE).expect("Failed to parse");
-
-        // Assert
-        assert_eq!(
-            sections,
-            vec![
-                SemanticTestSection::SourceCode {
-                    file_name: Some("main.sol".into()),
-                    content: "\nimport \"./lib.sol\";\ncontract C {\n    function f() public pure returns (uint) {\n        return Lib.f();\n    }\n}".to_string()
-                },
-                SemanticTestSection::SourceCode {
-                    file_name: Some("lib.sol".into()),
-                    content: "\nlibrary Lib {\n    function f() internal pure returns (uint) {\n        return 1;\n    }\n}".to_string()
-                },
-                SemanticTestSection::TestConfiguration {
-                    configuration: TestConfiguration { compile_via_yul: Some(true.into()), ..Default::default() },
-                },
-                SemanticTestSection::TestInputs {
-                    lines: vec!["f() -> 1".to_string()]
-                }
-            ]
-        )
-    }
-
-    #[test]
-    #[ignore = "Ignored and should be removed before making a PR"]
-    fn test() {
-        let files = revive_dt_common::iterators::FilesWithExtensionIterator::new(
-            "/Users/omarabdulla/parity/resolc-compiler-tests/fixtures/solidity/ethereum",
-        )
-        .with_allowed_extension("sol");
-
-        for file in files {
-            let content = std::fs::read_to_string(file).unwrap();
-            let sections = SemanticTestSection::parse_source_into_sections(content).unwrap();
-
-            println!("{sections:#?}");
-        }
-    }
-}

crates/format/src/semantic_tests/test_configuration.rs

@@ -1,200 +0,0 @@
-use std::str::FromStr;
-
-use revive_common::EVMVersion;
-
-use anyhow::{Error, Result, bail};
-
-/// The configuration parameters provided in the solidity semantic tests.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-pub struct TestConfiguration {
-    /// Controls if the test case compiles through the Yul IR.
-    pub compile_via_yul: Option<ItemConfig>,
-    /// Controls if the compilation should be done to EWASM.
-    pub compile_to_ewasm: Option<ItemConfig>,
-    /// Controls if ABI encoding should be restricted to the V1 ABI encoder.
-    pub abi_encoder_v1_only: Option<ItemConfig>,
-    /// Controls the EVM Version that the test is compatible with.
-    pub evm_version: Option<EvmVersionRequirement>,
-    /// Controls how the revert strings should be handled.
-    pub revert_strings: Option<RevertString>,
-    /// Controls if non-existent functions should be permitted or not.
-    pub allow_non_existing_functions: Option<bool>,
-    /// The list of bytecode formats that this test should be run against.
-    pub bytecode_format: Option<Vec<BytecodeFormat>>,
-}
-
-impl TestConfiguration {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn with_config(
-        &mut self,
-        key: impl AsRef<str>,
-        value: impl AsRef<str>,
-    ) -> Result<&mut Self> {
-        match key.as_ref() {
-            "compileViaYul" => self.compile_via_yul = Some(value.as_ref().parse()?),
-            "compileToEwasm" => self.compile_to_ewasm = Some(value.as_ref().parse()?),
-            "ABIEncoderV1Only" => self.abi_encoder_v1_only = Some(value.as_ref().parse()?),
-            "EVMVersion" => self.evm_version = Some(value.as_ref().parse()?),
-            "revertStrings" => self.revert_strings = Some(value.as_ref().parse()?),
-            "allowNonExistingFunctions" => {
-                self.allow_non_existing_functions = Some(value.as_ref().parse()?)
-            }
-            "bytecodeFormat" => {
-                self.bytecode_format = Some(
-                    value
-                        .as_ref()
-                        .split(',')
-                        .map(str::trim)
-                        .map(FromStr::from_str)
-                        .collect::<Result<Vec<_>>>()?,
-                )
-            }
-            _ => bail!("Unknown test configuration {}", key.as_ref()),
-        };
-        Ok(self)
-    }
-
-    pub fn new_from_pairs(
-        pairs: impl IntoIterator<Item = (impl AsRef<str>, impl AsRef<str>)>,
-    ) -> Result<Self> {
-        let mut this = Self::default();
-        pairs
-            .into_iter()
-            .try_fold(&mut this, |this, (key, value)| this.with_config(key, value))?;
-        Ok(this)
-    }
-}
-
-/// The configuration of a single item in the test configuration.
-#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum ItemConfig {
-    /// The configuration is set to e a boolean that's either `true` or `false`.
-    Boolean(bool),
-    /// The `also`
-    Also,
-}
-
-impl FromStr for ItemConfig {
-    type Err = Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "true" => Ok(Self::Boolean(true)),
-            "false" => Ok(Self::Boolean(false)),
-            "also" => Ok(Self::Also),
-            _ => bail!("Invalid ItemConfig {s}"),
-        }
-    }
-}
-
-impl From<bool> for ItemConfig {
-    fn from(value: bool) -> Self {
-        Self::Boolean(value)
-    }
-}
-
-impl TryFrom<String> for ItemConfig {
-    type Error = <ItemConfig as FromStr>::Err;
-
-    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
-        value.as_str().parse()
-    }
-}
-
-/// The options available for the revert strings.
-#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-pub enum RevertString {
-    #[default]
-    Default,
-    Debug,
-    Strip,
-    VerboseDebug,
-}
-
-impl FromStr for RevertString {
-    type Err = Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "default" => Ok(Self::Default),
-            "debug" => Ok(Self::Debug),
-            "strip" => Ok(Self::Strip),
-            "verboseDebug" => Ok(Self::VerboseDebug),
-            _ => bail!("Invalid RevertString {s}"),
-        }
-    }
-}
-
-impl TryFrom<String> for RevertString {
-    type Error = <RevertString as FromStr>::Err;
-
-    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
-        value.as_str().parse()
-    }
-}
-
-/// The set of available bytecode formats.
-#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum BytecodeFormat {
-    Legacy,
-    EofVersionGreaterThanOne,
-}
-
-impl FromStr for BytecodeFormat {
-    type Err = Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "legacy" => Ok(Self::Legacy),
-            ">=EOFv1" => Ok(Self::EofVersionGreaterThanOne),
-            _ => bail!("Invalid BytecodeFormat {s}"),
-        }
-    }
-}
-
-impl TryFrom<String> for BytecodeFormat {
-    type Error = <BytecodeFormat as FromStr>::Err;
-
-    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
-        value.as_str().parse()
-    }
-}
-
-#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum EvmVersionRequirement {
-    GreaterThan(EVMVersion),
-    GreaterThanOrEqual(EVMVersion),
-    LessThan(EVMVersion),
-    LessThanOrEqual(EVMVersion),
-    EqualTo(EVMVersion),
-}
-
-impl FromStr for EvmVersionRequirement {
-    type Err = Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s.as_bytes() {
-            [b'>', b'=', remaining @ ..] => Ok(Self::GreaterThanOrEqual(
-                str::from_utf8(remaining)?.try_into()?,
-            )),
-            [b'>', remaining @ ..] => Ok(Self::GreaterThan(str::from_utf8(remaining)?.try_into()?)),
-            [b'<', b'=', remaining @ ..] => Ok(Self::LessThanOrEqual(
-                str::from_utf8(remaining)?.try_into()?,
-            )),
-            [b'<', remaining @ ..] => Ok(Self::LessThan(str::from_utf8(remaining)?.try_into()?)),
-            [b'=', remaining @ ..] => Ok(Self::EqualTo(str::from_utf8(remaining)?.try_into()?)),
-            _ => bail!("Invalid EVM version requirement {s}"),
-        }
-    }
-}
-
-impl TryFrom<String> for EvmVersionRequirement {
-    type Error = <EvmVersionRequirement as FromStr>::Err;
-
-    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
-        value.as_str().parse()
-    }
-}

crates/format/src/traits.rs

@@ -1,22 +1,13 @@
-use std::collections::HashMap;
-
 use alloy::eips::BlockNumberOrTag;
-use alloy::json_abi::JsonAbi;
 use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
-use alloy_primitives::TxHash;
 use anyhow::Result;
 
-use crate::metadata::ContractInstance;
-
 /// A trait of the interface are required to implement to be used by the resolution logic that this
 /// crate implements to go from string calldata and into the bytes calldata.
 pub trait ResolverApi {
     /// Returns the ID of the chain that the node is on.
     fn chain_id(&self) -> impl Future<Output = Result<ChainId>>;
 
-    /// Returns the gas price for the specified transaction.
-    fn transaction_gas_price(&self, tx_hash: &TxHash) -> impl Future<Output = Result<u128>>;
-
     // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
     // when we implement the changes to the gas we need to adjust this to be a u64.
     /// Returns the gas limit of the specified block.
@@ -28,9 +19,6 @@ pub trait ResolverApi {
     /// Returns the difficulty of the specified block.
     fn block_difficulty(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<U256>>;
 
-    /// Returns the base fee of the specified block.
-    fn block_base_fee(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u64>>;
-
     /// Returns the hash of the specified block.
     fn block_hash(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<BlockHash>>;
 
@@ -43,108 +31,3 @@ pub trait ResolverApi {
     /// Returns the number of the last block.
     fn last_block_number(&self) -> impl Future<Output = Result<BlockNumber>>;
 }
-
-#[derive(Clone, Copy, Debug, Default)]
-/// Contextual information required by the code that's performing the resolution.
-pub struct ResolutionContext<'a> {
-    /// When provided the contracts provided here will be used for resolutions.
-    deployed_contracts: Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>,
-
-    /// When provided the variables in here will be used for performing resolutions.
-    variables: Option<&'a HashMap<String, U256>>,
-
-    /// When provided this block number will be treated as the tip of the chain.
-    block_number: Option<&'a BlockNumber>,
-
-    /// When provided the resolver will use this transaction hash for all of its resolutions.
-    transaction_hash: Option<&'a TxHash>,
-}
-
-impl<'a> ResolutionContext<'a> {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn new_from_parts(
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>>,
-        block_number: impl Into<Option<&'a BlockNumber>>,
-        transaction_hash: impl Into<Option<&'a TxHash>>,
-    ) -> Self {
-        Self {
-            deployed_contracts: deployed_contracts.into(),
-            variables: variables.into(),
-            block_number: block_number.into(),
-            transaction_hash: transaction_hash.into(),
-        }
-    }
-
-    pub fn with_deployed_contracts(
-        mut self,
-        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
-    ) -> Self {
-        self.deployed_contracts = deployed_contracts.into();
-        self
-    }
-
-    pub fn with_variables(
-        mut self,
-        variables: impl Into<Option<&'a HashMap<String, U256>>>,
-    ) -> Self {
-        self.variables = variables.into();
-        self
-    }
-
-    pub fn with_block_number(mut self, block_number: impl Into<Option<&'a BlockNumber>>) -> Self {
-        self.block_number = block_number.into();
-        self
-    }
-
-    pub fn with_transaction_hash(
-        mut self,
-        transaction_hash: impl Into<Option<&'a TxHash>>,
-    ) -> Self {
-        self.transaction_hash = transaction_hash.into();
-        self
-    }
-
-    pub fn resolve_block_number(&self, number: BlockNumberOrTag) -> BlockNumberOrTag {
-        match self.block_number {
-            Some(block_number) => match number {
-                BlockNumberOrTag::Latest => BlockNumberOrTag::Number(*block_number),
-                n @ (BlockNumberOrTag::Finalized
-                | BlockNumberOrTag::Safe
-                | BlockNumberOrTag::Earliest
-                | BlockNumberOrTag::Pending
-                | BlockNumberOrTag::Number(_)) => n,
-            },
-            None => number,
-        }
-    }
-
-    pub fn deployed_contract(&self, instance: &ContractInstance) -> Option<&(Address, JsonAbi)> {
-        self.deployed_contracts
-            .and_then(|deployed_contracts| deployed_contracts.get(instance))
-    }
-
-    pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
-        self.deployed_contract(instance).map(|(a, _)| a)
-    }
-
-    pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
-        self.deployed_contract(instance).map(|(_, a)| a)
-    }
-
-    pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {
-        self.variables
-            .and_then(|variables| variables.get(name.as_ref()))
-    }
-
-    pub fn tip_block_number(&self) -> Option<&'a BlockNumber> {
-        self.block_number
-    }
-
-    pub fn transaction_hash(&self) -> Option<&'a TxHash> {
-        self.transaction_hash
-    }
-}

crates/node/src/geth.rs

@@ -3,13 +3,9 @@
 use std::{
     fs::{File, OpenOptions, create_dir_all, remove_dir_all},
     io::{BufRead, BufReader, Read, Write},
-    ops::ControlFlow,
     path::PathBuf,
     process::{Child, Command, Stdio},
-    sync::{
+    sync::atomic::{AtomicU32, Ordering},
-        Arc,
-        atomic::{AtomicU32, Ordering},
-    },
     time::{Duration, Instant},
 };
 
@@ -17,7 +13,7 @@ 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, U256},
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
@@ -29,13 +25,11 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
-use anyhow::Context;
+use revive_dt_common::fs::clear_directory;
-use tracing::{Instrument, Level};
-
-use revive_dt_common::{fs::clear_directory, futures::poll};
 use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
+use tracing::Level;
 
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 
@@ -83,10 +77,6 @@ impl GethNode {
     const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
 
     const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
-    const TRANSACTION_TRACING_ERROR: &str = "historical state not available in path scheme yet";
-
-    const RECEIPT_POLLING_DURATION: Duration = Duration::from_secs(5 * 60);
-    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))]
@@ -112,8 +102,6 @@ impl GethNode {
         serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
 
         let mut child = Command::new(&self.geth)
-            .arg("--state.scheme")
-            .arg("hash")
             .arg("init")
             .arg("--datadir")
             .arg(&self.data_directory)
@@ -171,12 +159,6 @@ impl GethNode {
             .arg("0")
             .arg("--cache.blocklogs")
             .arg("512")
-            .arg("--state.scheme")
-            .arg("hash")
-            .arg("--syncmode")
-            .arg("full")
-            .arg("--gcmode")
-            .arg("archive")
             .stderr(stderr_logs_file.try_clone()?)
             .stdout(stdout_logs_file.try_clone()?)
             .spawn()?
@@ -266,16 +248,21 @@ impl GethNode {
 }
 
 impl EthereumNode for GethNode {
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let span = tracing::debug_span!("Submitting transaction", ?transaction);
+        let outer_span = tracing::debug_span!("Submitting transaction", ?transaction);
-        let _guard = span.enter();
+        let _outer_guard = outer_span.enter();
 
-        let provider = Arc::new(self.provider().await?);
+        let provider = self.provider().await?;
-        let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
+
+        let pending_transaction = provider.send_transaction(transaction).await?;
+        let transaction_hash = pending_transaction.tx_hash();
+
+        let span = tracing::info_span!("Awaiting transaction receipt", ?transaction_hash);
+        let _guard = span.enter();
 
         // The following is a fix for the "transaction indexing is in progress" error that we
         // used to get. You can find more information on this in the following GH issue in geth
@@ -295,64 +282,57 @@ impl EthereumNode for GethNode {
         // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
         // with exponential backoff each time we attempt to get the receipt and find that it's
         // not available.
-        poll(
+        let mut retries = 0;
-            Self::RECEIPT_POLLING_DURATION,
+        let mut total_wait_duration = Duration::from_secs(0);
-            Default::default(),
+        let max_allowed_wait_duration = Duration::from_secs(5 * 60);
-            move || {
+        loop {
-                let provider = provider.clone();
+            if total_wait_duration >= max_allowed_wait_duration {
-                async move {
+                tracing::error!(
-                    match provider.get_transaction_receipt(transaction_hash).await {
+                    ?total_wait_duration,
-                        Ok(Some(receipt)) => Ok(ControlFlow::Break(receipt)),
+                    ?max_allowed_wait_duration,
-                        Ok(None) => Ok(ControlFlow::Continue(())),
+                    retry_count = retries,
-                        Err(error) => {
+                    "Failed to get receipt after polling for it"
-                            let error_string = error.to_string();
+                );
-                            match error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
+                anyhow::bail!(
-                                true => Ok(ControlFlow::Continue(())),
+                    "Polled for receipt for {total_wait_duration:?} but failed to get it"
-                                false => Err(error.into()),
+                );
-                            }
-                        }
-                    }
-                }
-            },
-        )
-        .instrument(tracing::info_span!(
-            "Awaiting transaction receipt",
-            ?transaction_hash
-        ))
-        .await
             }
 
-    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+            match provider.get_transaction_receipt(*transaction_hash).await {
+                Ok(Some(receipt)) => {
+                    tracing::info!(?total_wait_duration, "Found receipt");
+                    break Ok(receipt);
+                }
+                Ok(None) => {}
+                Err(error) => {
+                    let error_string = error.to_string();
+                    if !error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
+                        break Err(error.into());
+                    }
+                }
+            };
+
+            let next_wait_duration = Duration::from_secs(2u64.pow(retries))
+                .min(max_allowed_wait_duration - total_wait_duration);
+            total_wait_duration += next_wait_duration;
+            retries += 1;
+
+            tokio::time::sleep(next_wait_duration).await;
+        }
+    }
+
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let provider = Arc::new(self.provider().await?);
+        let tx_hash = transaction.transaction_hash;
-        poll(
+        Ok(self
-            Self::TRACE_POLLING_DURATION,
+            .provider()
-            Default::default(),
+            .await?
-            move || {
+            .debug_trace_transaction(tx_hash, trace_options)
-                let provider = provider.clone();
+            .await?)
-                let trace_options = trace_options.clone();
-                async move {
-                    match provider
-                        .debug_trace_transaction(transaction.transaction_hash, trace_options)
-                        .await
-                    {
-                        Ok(trace) => Ok(ControlFlow::Break(trace)),
-                        Err(error) => {
-                            let error_string = error.to_string();
-                            match error_string.contains(Self::TRANSACTION_TRACING_ERROR) {
-                                true => Ok(ControlFlow::Continue(())),
-                                false => Err(error.into()),
-                            }
-                        }
-                    }
-                }
-            },
-        )
-        .await
     }
 
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
@@ -383,16 +363,6 @@ impl ResolverApi for GethNode {
             .map_err(Into::into)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
-        self.provider()
-            .await?
-            .get_transaction_receipt(*tx_hash)
-            .await?
-            .context("Failed to get the transaction receipt")
-            .map(|receipt| receipt.effective_gas_price)
-    }
-
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
@@ -420,22 +390,7 @@ impl ResolverApi for GethNode {
             .get_block_by_number(number)
             .await?
             .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+            .map(|block| block.header.difficulty)
-    }
-
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
-        self.provider()
-            .await?
-            .get_block_by_number(number)
-            .await?
-            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .and_then(|block| {
-                block
-                    .header
-                    .base_fee_per_gas
-                    .context("Failed to get the base fee per gas")
-            })
     }
 
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]

crates/node/src/kitchensink.rs

@@ -16,8 +16,7 @@ use alloy::{
         TransactionBuilderError, UnbuiltTransactionError,
     },
     primitives::{
-        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes,
+        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes, U256,
-        TxHash, U256,
     },
     providers::{
         Provider, ProviderBuilder,
@@ -31,7 +30,6 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
-use anyhow::Context;
 use revive_dt_common::fs::clear_directory;
 use revive_dt_format::traits::ResolverApi;
 use serde::{Deserialize, Serialize};
@@ -211,7 +209,7 @@ impl KitchensinkNode {
         if let Err(error) = Self::wait_ready(
             self.kitchensink_stderr_log_file_path().as_path(),
             Self::SUBSTRATE_READY_MARKER,
-            Duration::from_secs(60),
+            Duration::from_secs(30),
         ) {
             tracing::error!(
                 ?error,
@@ -240,7 +238,7 @@ impl KitchensinkNode {
         if let Err(error) = Self::wait_ready(
             self.proxy_stderr_log_file_path().as_path(),
             Self::ETH_PROXY_READY_MARKER,
-            Duration::from_secs(60),
+            Duration::from_secs(30),
         ) {
             tracing::error!(?error, "Failed to start proxy, shutting down gracefully");
             self.shutdown()?;
@@ -440,16 +438,6 @@ impl ResolverApi for KitchensinkNode {
             .map_err(Into::into)
     }
 
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
-        self.provider()
-            .await?
-            .get_transaction_receipt(*tx_hash)
-            .await?
-            .context("Failed to get the transaction receipt")
-            .map(|receipt| receipt.effective_gas_price)
-    }
-
     #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
@@ -477,22 +465,7 @@ impl ResolverApi for KitchensinkNode {
             .get_block_by_number(number)
             .await?
             .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+            .map(|block| block.header.difficulty)
-    }
-
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
-        self.provider()
-            .await?
-            .get_block_by_number(number)
-            .await?
-            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .and_then(|block| {
-                block
-                    .header
-                    .base_fee_per_gas
-                    .context("Failed to get the base fee per gas")
-            })
     }
 
     #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]

crates/solc-binaries/src/cache.rs

@@ -11,14 +11,14 @@ use std::{
 
 use tokio::sync::Mutex;
 
-use crate::download::SolcDownloader;
+use crate::download::GHDownloader;
 
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
 
 pub(crate) async fn get_or_download(
     working_directory: &Path,
-    downloader: &SolcDownloader,
+    downloader: &GHDownloader,
 ) -> anyhow::Result<PathBuf> {
     let target_directory = working_directory
         .join(SOLC_CACHE_DIRECTORY)
@@ -38,7 +38,7 @@ pub(crate) async fn get_or_download(
     Ok(target_file)
 }
 
-async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
+async fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
     tracing::info!("caching file: {}", path.display());
 
     let Ok(file) = File::create_new(path) else {

crates/solc-binaries/src/download.rs

@@ -38,21 +38,21 @@ impl List {
     }
 }
 
-/// Download solc binaries from the official SolidityLang site
+/// Download solc binaries from GitHub releases (IPFS links aren't reliable).
 #[derive(Clone, Debug)]
-pub struct SolcDownloader {
+pub struct GHDownloader {
     pub version: Version,
     pub target: &'static str,
     pub list: &'static str,
 }
 
-impl SolcDownloader {
+impl GHDownloader {
-    pub const BASE_URL: &str = "https://binaries.soliditylang.org";
+    pub const BASE_URL: &str = "https://github.com/ethereum/solidity/releases/download";
 
-    pub const LINUX_NAME: &str = "linux-amd64";
+    pub const LINUX_NAME: &str = "solc-static-linux";
-    pub const MACOSX_NAME: &str = "macosx-amd64";
+    pub const MACOSX_NAME: &str = "solc-macos";
-    pub const WINDOWS_NAME: &str = "windows-amd64";
+    pub const WINDOWS_NAME: &str = "solc-windows.exe";
-    pub const WASM_NAME: &str = "wasm";
+    pub const WASM_NAME: &str = "soljson.js";
 
     async fn new(
         version: impl Into<VersionOrRequirement>,
@@ -102,27 +102,26 @@ impl SolcDownloader {
         Self::new(version, Self::WASM_NAME, List::WASM_URL).await
     }
 
+    /// Returns the download link.
+    pub fn url(&self) -> String {
+        format!("{}/v{}/{}", Self::BASE_URL, &self.version, &self.target)
+    }
+
     /// Download the solc binary.
     ///
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
     pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
         tracing::info!("downloading solc: {self:?}");
-        let builds = List::download(self.list).await?.builds;
+        let expected_digest = List::download(self.list)
-        let build = builds
+            .await?
+            .builds
             .iter()
             .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
+            .map(|b| b.sha256.strip_prefix("0x").unwrap_or(&b.sha256).to_string())?;
 
-        let path = build.path.clone();
+        let file = reqwest::get(self.url()).await?.bytes().await?.to_vec();
-        let expected_digest = build
-            .sha256
-            .strip_prefix("0x")
-            .unwrap_or(&build.sha256)
-            .to_string();
-        let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
-
-        let file = reqwest::get(url).await?.bytes().await?.to_vec();
 
         if hex::encode(Sha256::digest(&file)) != expected_digest {
             anyhow::bail!("sha256 mismatch for solc version {}", self.version);
@@ -134,7 +133,7 @@ impl SolcDownloader {
 
 #[cfg(test)]
 mod tests {
-    use crate::{download::SolcDownloader, list::List};
+    use crate::{download::GHDownloader, list::List};
 
     #[tokio::test]
     async fn try_get_windows() {
@@ -142,7 +141,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        SolcDownloader::windows(version)
+        GHDownloader::windows(version)
             .await
             .unwrap()
             .download()
@@ -156,7 +155,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        SolcDownloader::macosx(version)
+        GHDownloader::macosx(version)
             .await
             .unwrap()
             .download()
@@ -170,7 +169,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        SolcDownloader::linux(version)
+        GHDownloader::linux(version)
             .await
             .unwrap()
             .download()
@@ -181,7 +180,7 @@ mod tests {
     #[tokio::test]
     async fn try_get_wasm() {
         let version = List::download(List::WASM_URL).await.unwrap().latest_release;
-        SolcDownloader::wasm(version)
+        GHDownloader::wasm(version)
             .await
             .unwrap()
             .download()

crates/solc-binaries/src/lib.rs

@@ -6,7 +6,7 @@
 use std::path::{Path, PathBuf};
 
 use cache::get_or_download;
-use download::SolcDownloader;
+use download::GHDownloader;
 
 use revive_dt_common::types::VersionOrRequirement;
 
@@ -25,13 +25,13 @@ pub async fn download_solc(
     wasm: bool,
 ) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
-        SolcDownloader::wasm(version).await
+        GHDownloader::wasm(version).await
     } else if cfg!(target_os = "linux") {
-        SolcDownloader::linux(version).await
+        GHDownloader::linux(version).await
     } else if cfg!(target_os = "macos") {
-        SolcDownloader::macosx(version).await
+        GHDownloader::macosx(version).await
     } else if cfg!(target_os = "windows") {
-        SolcDownloader::windows(version).await
+        GHDownloader::windows(version).await
     } else {
         unimplemented!()
     }?;