Cached compiler artifacts (#143)

* WIP compilation cache

* Implement a persistent compilation cache

* Correct the key and value encoding for the cache

crates/core/Cargo.toml

@@ -23,12 +23,17 @@ revive-dt-report = { workspace = true }
 
 alloy = { workspace = true }
 anyhow = { workspace = true }
+bson = { workspace = true }
+cacache = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true }
+once_cell = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 temp-dir = { workspace = true }
+tempfile = { workspace = true }

crates/core/src/cached_compiler.rs

@@ -0,0 +1,261 @@
+//! A wrapper around the compiler which allows for caching of compilation artifacts so that they can
+//! be reused between runs.
+
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use futures::FutureExt;
+use revive_dt_common::iterators::FilesWithExtensionIterator;
+use revive_dt_compiler::{Compiler, CompilerOutput, Mode, SolidityCompiler};
+use revive_dt_config::Arguments;
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, Metadata};
+
+use alloy::{hex::ToHexExt, json_abi::JsonAbi, primitives::Address};
+use anyhow::{Error, Result};
+use once_cell::sync::Lazy;
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use tokio::sync::{Mutex, RwLock};
+use tracing::{Instrument, debug, debug_span, instrument};
+
+use crate::Platform;
+
+pub struct CachedCompiler(ArtifactsCache);
+
+impl CachedCompiler {
+    pub async fn new(path: impl AsRef<Path>, invalidate_cache: bool) -> Result<Self> {
+        let mut cache = ArtifactsCache::new(path);
+        if invalidate_cache {
+            cache = cache.with_invalidated_cache().await?;
+        }
+        Ok(Self(cache))
+    }
+
+    /// Compiles or gets the compilation artifacts from the cache.
+    #[instrument(
+        level = "debug",
+        skip_all,
+        fields(
+            metadata_file_path = %metadata_file_path.as_ref().display(),
+            %mode,
+            platform = P::config_id().to_string()
+        ),
+        err
+    )]
+    pub async fn compile_contracts<P: Platform>(
+        &self,
+        metadata: &Metadata,
+        metadata_file_path: impl AsRef<Path>,
+        mode: &Mode,
+        config: &Arguments,
+        deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+    ) -> Result<(CompilerOutput, Version)> {
+        static CACHE_KEY_LOCK: Lazy<RwLock<HashMap<CacheKey, Arc<Mutex<()>>>>> =
+            Lazy::new(Default::default);
+
+        let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
+        let compiler_path = <P::Compiler as SolidityCompiler>::get_compiler_executable(
+            config,
+            compiler_version_or_requirement,
+        )
+        .await?;
+        let compiler_version =
+            <P::Compiler as SolidityCompiler>::new(compiler_path.clone()).version()?;
+
+        let cache_key = CacheKey {
+            platform_key: P::config_id().to_string(),
+            compiler_version: compiler_version.clone(),
+            metadata_file_path: metadata_file_path.as_ref().to_path_buf(),
+            solc_mode: mode.clone(),
+        };
+
+        let compilation_callback = || {
+            async move {
+                compile_contracts::<P>(
+                    metadata.directory()?,
+                    compiler_path,
+                    metadata.files_to_compile()?,
+                    mode,
+                    deployed_libraries,
+                )
+                .map(|compilation_result| compilation_result.map(CacheValue::new))
+                .await
+            }
+            .instrument(debug_span!(
+                "Running compilation for the cache key",
+                cache_key.platform_key = %cache_key.platform_key,
+                cache_key.compiler_version = %cache_key.compiler_version,
+                cache_key.metadata_file_path = %cache_key.metadata_file_path.display(),
+                cache_key.solc_mode = %cache_key.solc_mode,
+            ))
+        };
+
+        let compiled_contracts = match deployed_libraries {
+            // If deployed libraries have been specified then we will re-compile the contract as it
+            // means that linking is required in this case.
+            Some(_) => {
+                debug!("Deployed libraries defined, recompilation must take place");
+                debug!("Cache miss");
+                compilation_callback().await?.compiler_output
+            }
+            // If no deployed libraries are specified then we can follow the cached flow and attempt
+            // to lookup the compilation artifacts in the cache.
+            None => {
+                debug!("Deployed libraries undefined, attempting to make use of cache");
+
+                // Lock this specific cache key such that we do not get inconsistent state. We want
+                // that when multiple cases come in asking for the compilation artifacts then they
+                // don't all trigger a compilation if there's a cache miss. Hence, the lock here.
+                let read_guard = CACHE_KEY_LOCK.read().await;
+                let mutex = match read_guard.get(&cache_key).cloned() {
+                    Some(value) => value,
+                    None => {
+                        drop(read_guard);
+                        CACHE_KEY_LOCK
+                            .write()
+                            .await
+                            .entry(cache_key.clone())
+                            .or_default()
+                            .clone()
+                    }
+                };
+                let _guard = mutex.lock().await;
+
+                self.0
+                    .get_or_insert_with(&cache_key, compilation_callback)
+                    .await
+                    .map(|value| value.compiler_output)?
+            }
+        };
+
+        Ok((compiled_contracts, compiler_version))
+    }
+}
+
+async fn compile_contracts<P: Platform>(
+    metadata_directory: impl AsRef<Path>,
+    compiler_path: impl AsRef<Path>,
+    mut files_to_compile: impl Iterator<Item = PathBuf>,
+    mode: &Mode,
+    deployed_libraries: Option<&HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>>,
+) -> Result<CompilerOutput> {
+    let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())
+        .with_allowed_extension("sol")
+        .with_use_cached_fs(true)
+        .collect::<Vec<_>>();
+
+    Compiler::<P::Compiler>::new()
+        .with_allow_path(metadata_directory)
+        // Handling the modes
+        .with_optimization(mode.optimize_setting)
+        .with_pipeline(mode.pipeline)
+        // Adding the contract sources to the compiler.
+        .try_then(|compiler| {
+            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(path))
+        })?
+        // Adding the deployed libraries to the compiler.
+        .then(|compiler| {
+            deployed_libraries
+                .iter()
+                .flat_map(|value| value.iter())
+                .map(|(instance, (ident, address, abi))| (instance, ident, address, abi))
+                .flat_map(|(_, ident, address, _)| {
+                    all_sources_in_dir
+                        .iter()
+                        .map(move |path| (ident, address, path))
+                })
+                .fold(compiler, |compiler, (ident, address, path)| {
+                    compiler.with_library(path, ident.as_str(), *address)
+                })
+        })
+        .try_build(compiler_path)
+        .await
+}
+
+struct ArtifactsCache {
+    path: PathBuf,
+}
+
+impl ArtifactsCache {
+    pub fn new(path: impl AsRef<Path>) -> Self {
+        Self {
+            path: path.as_ref().to_path_buf(),
+        }
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn with_invalidated_cache(self) -> Result<Self> {
+        cacache::clear(self.path.as_path())
+            .await
+            .map_err(Into::<Error>::into)?;
+        Ok(self)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn insert(&self, key: &CacheKey, value: &CacheValue) -> Result<()> {
+        let key = bson::to_vec(key)?;
+        let value = bson::to_vec(value)?;
+        cacache::write(self.path.as_path(), key.encode_hex(), value).await?;
+        Ok(())
+    }
+
+    pub async fn get(&self, key: &CacheKey) -> Option<CacheValue> {
+        let key = bson::to_vec(key).ok()?;
+        let value = cacache::read(self.path.as_path(), key.encode_hex())
+            .await
+            .ok()?;
+        let value = bson::from_slice::<CacheValue>(&value).ok()?;
+        Some(value)
+    }
+
+    #[instrument(level = "debug", skip_all, err)]
+    pub async fn get_or_insert_with(
+        &self,
+        key: &CacheKey,
+        callback: impl AsyncFnOnce() -> Result<CacheValue>,
+    ) -> Result<CacheValue> {
+        match self.get(key).await {
+            Some(value) => {
+                debug!("Cache hit");
+                Ok(value)
+            }
+            None => {
+                debug!("Cache miss");
+                let value = callback().await?;
+                self.insert(key, &value).await?;
+                Ok(value)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+struct CacheKey {
+    /// The platform name that this artifact was compiled for. For example, this could be EVM or
+    /// PVM.
+    platform_key: String,
+
+    /// The version of the compiler that was used to compile the artifacts.
+    compiler_version: Version,
+
+    /// The path of the metadata file that the compilation artifacts are for.
+    metadata_file_path: PathBuf,
+
+    /// The mode that the compilation artifacts where compiled with.
+    solc_mode: Mode,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct CacheValue {
+    /// The compiler output from the compilation run.
+    compiler_output: CompilerOutput,
+}
+
+impl CacheValue {
+    pub fn new(compiler_output: CompilerOutput) -> Self {
+        Self { compiler_output }
+    }
+}

crates/core/src/driver/mod.rs

@@ -31,7 +31,7 @@ use revive_dt_format::input::{
     BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
     StorageEmptyAssertion,
 };
-use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
+use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
 use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
@@ -44,7 +44,7 @@ pub struct CaseState<T: Platform> {
     compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 
     /// This map stores the contracts deployments for this case.
-    deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
+    deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
 
     /// This map stores the variables used for each one of the cases contained in the metadata
     /// file.
@@ -63,7 +63,7 @@ where
     pub fn new(
         compiler_version: Version,
         compiled_contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
-        deployed_contracts: HashMap<ContractInstance, (Address, JsonAbi)>,
+        deployed_contracts: HashMap<ContractInstance, (ContractIdent, Address, JsonAbi)>,
     ) -> Self {
         Self {
             compiled_contracts,
@@ -155,17 +155,10 @@ where
     async fn handle_input_contract_deployment(
         &mut self,
         metadata: &Metadata,
-        case_idx: CaseIdx,
+        _: CaseIdx,
         input: &Input,
         node: &T::Blockchain,
     ) -> anyhow::Result<HashMap<ContractInstance, TransactionReceipt>> {
-        let span = tracing::debug_span!(
-            "Handling contract deployment",
-            ?case_idx,
-            instance = ?input.instance
-        );
-        let _guard = span.enter();
-
         let mut instances_we_must_deploy = IndexMap::<ContractInstance, bool>::new();
         for instance in input.find_all_contract_instances().into_iter() {
             if !self.deployed_contracts.contains_key(&instance) {
@@ -316,9 +309,6 @@ where
         resolver: &impl ResolverApi,
         tracing_result: &CallFrame,
     ) -> anyhow::Result<()> {
-        let span = tracing::info_span!("Handling input expectations");
-        let _guard = span.enter();
-
         // Resolving the `input.expected` into a series of expectations that we can then assert on.
         let mut expectations = match input {
             Input {
@@ -508,9 +498,6 @@ where
         execution_receipt: TransactionReceipt,
         node: &T::Blockchain,
     ) -> anyhow::Result<(TransactionReceipt, GethTrace, DiffMode)> {
-        let span = tracing::info_span!("Handling input diff");
-        let _guard = span.enter();
-
         let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
             diff_mode: Some(true),
             disable_code: None,
@@ -662,7 +649,7 @@ where
         value: Option<EtherValue>,
         node: &T::Blockchain,
     ) -> anyhow::Result<(Address, JsonAbi, Option<TransactionReceipt>)> {
-        if let Some((address, abi)) = self.deployed_contracts.get(contract_instance) {
+        if let Some((_, address, abi)) = self.deployed_contracts.get(contract_instance) {
             return Ok((*address, abi.clone(), None));
         }
 
@@ -746,8 +733,10 @@ where
             "Deployed contract"
         );
 
-        self.deployed_contracts
-            .insert(contract_instance.clone(), (address, abi.clone()));
+        self.deployed_contracts.insert(
+            contract_instance.clone(),
+            (contract_ident, address, abi.clone()),
+        );
 
         Ok((address, abi, Some(receipt)))
     }

crates/core/src/main.rs

@@ -1,3 +1,5 @@
+mod cached_compiler;
+
 use std::{
     collections::HashMap,
     path::{Path, PathBuf},
@@ -6,26 +8,21 @@ use std::{
 };
 
 use alloy::{
-    json_abi::JsonAbi,
     network::{Ethereum, TransactionBuilder},
-    primitives::Address,
     rpc::types::TransactionRequest,
 };
 use anyhow::Context;
 use clap::Parser;
 use futures::stream::futures_unordered::FuturesUnordered;
 use futures::{Stream, StreamExt};
-use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_node_interaction::EthereumNode;
-use semver::Version;
 use temp_dir::TempDir;
-use tokio::sync::{Mutex, RwLock, mpsc};
+use tokio::sync::mpsc;
 use tracing::{Instrument, Level};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 use revive_dt_common::types::Mode;
 use revive_dt_compiler::SolidityCompiler;
-use revive_dt_compiler::{Compiler, CompilerOutput};
 use revive_dt_config::*;
 use revive_dt_core::{
     Geth, Kitchensink, Platform,
@@ -35,21 +32,14 @@ use revive_dt_format::{
     case::{Case, CaseIdx},
     corpus::Corpus,
     input::{Input, Step},
-    metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
+    metadata::{ContractPathAndIdent, Metadata, MetadataFile},
 };
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
 
-static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
+use crate::cached_compiler::CachedCompiler;
 
-type CompilationCache = Arc<
-    RwLock<
-        HashMap<
-            (PathBuf, Mode, TestingPlatform),
-            Arc<Mutex<Option<Arc<(Version, CompilerOutput)>>>>,
-        >,
-    >,
->;
+static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
 /// this represents a single "test"; a mode, path and collection of cases.
 #[derive(Clone)]
@@ -146,7 +136,7 @@ where
     let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();
 
     let tests = prepare_tests::<L, F>(args, metadata_files);
-    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx)?;
+    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx).await?;
     let status_reporter_task = start_reporter_task(report_rx);
 
     tokio::join!(status_reporter_task, driver_task);
@@ -246,18 +236,17 @@ where
             let is_supported = does_compiler_support_mode::<L>(args, &test.mode).await.ok().unwrap_or(false) &&
                 does_compiler_support_mode::<F>(args, &test.mode).await.ok().unwrap_or(false);
 
-            tracing::warn!(
-                metadata_file_path = %test.path.display(),
-                case_idx = %test.case_idx,
-                case_name = ?test.case.name,
-                mode = %test.mode,
-                "Skipping test as one or both of the compilers don't support it"
-            );
-
             // We filter_map to avoid needing to clone `test`, but return it as-is.
             if is_supported {
                 Some(test)
             } else {
+                tracing::warn!(
+                    metadata_file_path = %test.path.display(),
+                    case_idx = %test.case_idx,
+                    case_name = ?test.case.name,
+                    mode = %test.mode,
+                    "Skipping test as one or both of the compilers don't support it"
+                );
                 None
             }
         })
@@ -279,7 +268,7 @@ async fn does_compiler_support_mode<P: Platform>(
     ))
 }
 
-fn start_driver_task<L, F>(
+async fn start_driver_task<L, F>(
     args: &Arguments,
     tests: impl Stream<Item = Test>,
     span: Span,
@@ -293,8 +282,14 @@ where
 {
     let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
     let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
-    let compilation_cache = Arc::new(RwLock::new(HashMap::new()));
     let number_concurrent_tasks = args.number_of_concurrent_tasks();
+    let cached_compiler = Arc::new(
+        CachedCompiler::new(
+            args.directory().join("compilation_cache"),
+            args.invalidate_compilation_cache,
+        )
+        .await?,
+    );
 
     Ok(tests.for_each_concurrent(
         // We want to limit the concurrent tasks here because:
@@ -308,8 +303,8 @@ where
         move |test| {
             let leader_nodes = leader_nodes.clone();
             let follower_nodes = follower_nodes.clone();
-            let compilation_cache = compilation_cache.clone();
             let report_tx = report_tx.clone();
+            let cached_compiler = cached_compiler.clone();
 
             async move {
                 let leader_node = leader_nodes.round_robbin();
@@ -330,7 +325,7 @@ where
                     &test.case,
                     test.mode.clone(),
                     args,
-                    compilation_cache.clone(),
+                    cached_compiler,
                     leader_node,
                     follower_node,
                     span,
@@ -420,7 +415,7 @@ async fn handle_case_driver<L, F>(
     case: &Case,
     mode: Mode,
     config: &Arguments,
-    compilation_cache: CompilationCache,
+    cached_compiler: Arc<CachedCompiler>,
     leader_node: &L::Blockchain,
     follower_node: &F::Blockchain,
     _: Span,
@@ -431,27 +426,19 @@ where
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let leader_pre_link_contracts = get_or_build_contracts::<L>(
-        metadata,
-        metadata_file_path,
-        mode.clone(),
-        config,
-        compilation_cache.clone(),
-        &HashMap::new(),
-    )
-    .await?;
-    let follower_pre_link_contracts = get_or_build_contracts::<F>(
-        metadata,
-        metadata_file_path,
-        mode.clone(),
-        config,
-        compilation_cache.clone(),
-        &HashMap::new(),
-    )
-    .await?;
+    let leader_pre_link_contracts = cached_compiler
+        .compile_contracts::<L>(metadata, metadata_file_path, &mode, config, None)
+        .await?
+        .0
+        .contracts;
+    let follower_pre_link_contracts = cached_compiler
+        .compile_contracts::<F>(metadata, metadata_file_path, &mode, config, None)
+        .await?
+        .0
+        .contracts;
 
-    let mut leader_deployed_libraries = HashMap::new();
-    let mut follower_deployed_libraries = HashMap::new();
+    let mut leader_deployed_libraries = None::<HashMap<_, _>>;
+    let mut follower_deployed_libraries = None::<HashMap<_, _>>;
     let mut contract_sources = metadata.contract_sources()?;
     for library_instance in metadata
         .libraries
@@ -467,14 +454,10 @@ where
             .context("Failed to find the contract source")?;
 
         let (leader_code, leader_abi) = leader_pre_link_contracts
-            .1
-            .contracts
             .get(&library_source_path)
             .and_then(|contracts| contracts.get(library_ident.as_str()))
             .context("Declared library was not compiled")?;
         let (follower_code, follower_abi) = follower_pre_link_contracts
-            .1
-            .contracts
             .get(&library_source_path)
             .and_then(|contracts| contracts.get(library_ident.as_str()))
             .context("Declared library was not compiled")?;
@@ -567,81 +550,52 @@ where
             anyhow::bail!("Contract deployment didn't return an address");
         };
 
-        leader_deployed_libraries.insert(
+        leader_deployed_libraries.get_or_insert_default().insert(
             library_instance.clone(),
-            (leader_library_address, leader_abi.clone()),
+            (
+                library_ident.clone(),
+                leader_library_address,
+                leader_abi.clone(),
+            ),
         );
-        follower_deployed_libraries.insert(
+        follower_deployed_libraries.get_or_insert_default().insert(
             library_instance.clone(),
-            (follower_library_address, follower_abi.clone()),
+            (
+                library_ident,
+                follower_library_address,
+                follower_abi.clone(),
+            ),
         );
     }
 
-    let metadata_file_contains_libraries = metadata
-        .libraries
-        .iter()
-        .flat_map(|map| map.iter())
-        .flat_map(|(_, value)| value.iter())
-        .next()
-        .is_some();
-    let compiled_contracts_require_linking = leader_pre_link_contracts
-        .1
-        .contracts
-        .values()
-        .chain(follower_pre_link_contracts.1.contracts.values())
-        .flat_map(|value| value.values())
-        .any(|(code, _)| !code.chars().all(|char| char.is_ascii_hexdigit()));
-    let (leader_compiled_contracts, follower_compiled_contracts) =
-        if metadata_file_contains_libraries && compiled_contracts_require_linking {
-            let leader_key = (
-                metadata_file_path.to_path_buf(),
-                mode.clone(),
-                L::config_id(),
-            );
-            let follower_key = (
-                metadata_file_path.to_path_buf(),
-                mode.clone(),
-                F::config_id(),
-            );
-            {
-                let mut cache = compilation_cache.write().await;
-                cache.remove(&leader_key);
-                cache.remove(&follower_key);
-            }
-
-            let leader_post_link_contracts = get_or_build_contracts::<L>(
-                metadata,
-                metadata_file_path,
-                mode.clone(),
-                config,
-                compilation_cache.clone(),
-                &leader_deployed_libraries,
-            )
-            .await?;
-            let follower_post_link_contracts = get_or_build_contracts::<F>(
-                metadata,
-                metadata_file_path,
-                mode.clone(),
-                config,
-                compilation_cache,
-                &follower_deployed_libraries,
-            )
-            .await?;
-
-            (leader_post_link_contracts, follower_post_link_contracts)
-        } else {
-            (leader_pre_link_contracts, follower_pre_link_contracts)
-        };
+    let (leader_post_link_contracts, leader_compiler_version) = cached_compiler
+        .compile_contracts::<L>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            leader_deployed_libraries.as_ref(),
+        )
+        .await?;
+    let (follower_post_link_contracts, follower_compiler_version) = cached_compiler
+        .compile_contracts::<F>(
+            metadata,
+            metadata_file_path,
+            &mode,
+            config,
+            follower_deployed_libraries.as_ref(),
+        )
+        .await?;
 
     let leader_state = CaseState::<L>::new(
-        leader_compiled_contracts.0.clone(),
-        leader_compiled_contracts.1.contracts.clone(),
-        leader_deployed_libraries,
+        leader_compiler_version,
+        leader_post_link_contracts.contracts,
+        leader_deployed_libraries.unwrap_or_default(),
     );
     let follower_state = CaseState::<F>::new(
-        follower_compiled_contracts.0.clone(),
-        follower_compiled_contracts.1.contracts.clone(),
-        follower_deployed_libraries,
+        follower_compiler_version,
+        follower_post_link_contracts.contracts,
+        follower_deployed_libraries.unwrap_or_default(),
     );
 
     let mut driver = CaseDriver::<L, F>::new(
@@ -656,119 +610,6 @@ where
     driver.execute().await
 }
 
-async fn get_or_build_contracts<P: Platform>(
-    metadata: &Metadata,
-    metadata_file_path: &Path,
-    mode: Mode,
-    config: &Arguments,
-    compilation_cache: CompilationCache,
-    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
-) -> anyhow::Result<Arc<(Version, CompilerOutput)>> {
-    let key = (
-        metadata_file_path.to_path_buf(),
-        mode.clone(),
-        P::config_id(),
-    );
-    if let Some(compilation_artifact) = compilation_cache.read().await.get(&key).cloned() {
-        let mut compilation_artifact = compilation_artifact.lock().await;
-        match *compilation_artifact {
-            Some(ref compiled_contracts) => {
-                tracing::debug!(?key, "Compiled contracts cache hit");
-                return Ok(compiled_contracts.clone());
-            }
-            None => {
-                tracing::debug!(?key, "Compiled contracts cache miss");
-                let compiled_contracts = compile_contracts::<P>(
-                    metadata,
-                    metadata_file_path,
-                    &mode,
-                    config,
-                    deployed_libraries,
-                )
-                .await?;
-                let compiled_contracts = Arc::new(compiled_contracts);
-
-                *compilation_artifact = Some(compiled_contracts.clone());
-                return Ok(compiled_contracts.clone());
-            }
-        }
-    };
-
-    tracing::debug!(?key, "Compiled contracts cache miss");
-    let mutex = {
-        let mut compilation_cache = compilation_cache.write().await;
-        let mutex = Arc::new(Mutex::new(None));
-        compilation_cache.insert(key, mutex.clone());
-        mutex
-    };
-    let mut compilation_artifact = mutex.lock().await;
-
-    let compiled_contracts = compile_contracts::<P>(
-        metadata,
-        metadata_file_path,
-        &mode,
-        config,
-        deployed_libraries,
-    )
-    .await?;
-    let compiled_contracts = Arc::new(compiled_contracts);
-
-    *compilation_artifact = Some(compiled_contracts.clone());
-    Ok(compiled_contracts.clone())
-}
-
-async fn compile_contracts<P: Platform>(
-    metadata: &Metadata,
-    metadata_file_path: &Path,
-    mode: &Mode,
-    config: &Arguments,
-    deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
-) -> anyhow::Result<(Version, CompilerOutput)> {
-    let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
-    let compiler_path =
-        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.optimize_setting)
-        .with_pipeline(mode.pipeline);
-    let mut compiler = metadata
-        .files_to_compile()?
-        .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
-    for (library_instance, (library_address, _)) in deployed_libraries.iter() {
-        let library_ident = &metadata
-            .contracts
-            .as_ref()
-            .and_then(|contracts| contracts.get(library_instance))
-            .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
-        // into them. We do not have access to this information and therefore we choose an easier,
-        // yet more compute intensive route, of telling solc that all of the files need to link the
-        // library and it will only perform the linking for the files that do actually need the
-        // library.
-        compiler = FilesWithExtensionIterator::new(metadata.directory()?)
-            .with_allowed_extension("sol")
-            .with_use_cached_fs(true)
-            .fold(compiler, |compiler, path| {
-                compiler.with_library(&path, library_ident.as_str(), *library_address)
-            });
-    }
-
-    let compiler_output = compiler.try_build(compiler_path).await?;
-
-    Ok((compiler_version, compiler_output))
-}
-
 async fn execute_corpus(
     args: &Arguments,
     tests: &[MetadataFile],
@@ -800,28 +641,40 @@ async fn compile_corpus(
             .map(move |solc_mode| (metadata, solc_mode))
     });
 
+    let file = tempfile::NamedTempFile::new().expect("Failed to create temp file");
+    let cached_compiler = CachedCompiler::new(file.path(), false)
+        .await
+        .map(Arc::new)
+        .expect("Failed to create the cached compiler");
+
     futures::stream::iter(tests)
-        .for_each_concurrent(None, |(metadata, mode)| async move {
-            match platform {
-                TestingPlatform::Geth => {
-                    let _ = compile_contracts::<Geth>(
-                        &metadata.content,
-                        &metadata.path,
-                        &mode,
-                        config,
-                        &Default::default(),
-                    )
-                    .await;
-                }
-                TestingPlatform::Kitchensink => {
-                    let _ = compile_contracts::<Geth>(
-                        &metadata.content,
-                        &metadata.path,
-                        &mode,
-                        config,
-                        &Default::default(),
-                    )
-                    .await;
+        .for_each_concurrent(None, |(metadata, mode)| {
+            let cached_compiler = cached_compiler.clone();
+
+            async move {
+                match platform {
+                    TestingPlatform::Geth => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Geth>(
+                                metadata,
+                                metadata.path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
+                    TestingPlatform::Kitchensink => {
+                        let _ = cached_compiler
+                            .compile_contracts::<Kitchensink>(
+                                metadata,
+                                metadata.path.as_path(),
+                                &mode,
+                                config,
+                                None,
+                            )
+                            .await;
+                    }
                 }
             }
         })