feat(zk): zksolc linking

crates/common/src/compile.rs

@@ -19,17 +19,14 @@ use foundry_compilers::{
     solc::SolcSettings,
     Artifact, Project, ProjectBuilder, ProjectCompileOutput, ProjectPathsConfig, SolcConfig,
 };
-use foundry_zksync_compilers::{
-    compilers::{
-        artifact_output::zk::ZkArtifactOutput,
-        zksolc::{ZkSolc, ZkSolcCompiler},
-    },
-    libraries::{self, ZkMissingLibrary},
+use foundry_zksync_compilers::compilers::{
+    artifact_output::zk::ZkArtifactOutput,
+    zksolc::{ZkSolc, ZkSolcCompiler},
 };
 
 use num_format::{Locale, ToFormattedString};
 use std::{
-    collections::{BTreeMap, HashSet},
+    collections::BTreeMap,
     fmt::Display,
     io::IsTerminal,
     path::{Path, PathBuf},
@@ -336,7 +333,7 @@ impl ProjectCompiler {
             let zksolc_version = ZkSolc::get_version_for_path(&project.compiler.zksolc)?;
             Report::new(SpinnerReporter::spawn_with(format!("Using zksolc-{zksolc_version}")));
         }
-        self.zksync_compile_with(&project.paths.root, || {
+        self.zksync_compile_with(|| {
             let files_to_compile =
                 if !files.is_empty() { files } else { project.paths.input_files() };
             let sources = Source::read_all(files_to_compile)?;
@@ -349,7 +346,6 @@ impl ProjectCompiler {
     #[instrument(target = "forge::compile", skip_all)]
     fn zksync_compile_with<F>(
         self,
-        root_path: impl AsRef<Path>,
         f: F,
     ) -> Result<ProjectCompileOutput<ZkSolcCompiler, ZkArtifactOutput>>
     where
@@ -394,7 +390,7 @@ impl ProjectCompiler {
                 sh_println!("{output}")?;
             }
 
-            self.zksync_handle_output(root_path, &output)?;
+            self.zksync_handle_output(&output)?;
         }
 
         Ok(output)
@@ -403,71 +399,11 @@ impl ProjectCompiler {
     /// If configured, this will print sizes or names
     fn zksync_handle_output(
         &self,
-        root_path: impl AsRef<Path>,
         output: &ProjectCompileOutput<ZkSolcCompiler, ZkArtifactOutput>,
     ) -> Result<()> {
         let print_names = self.print_names.unwrap_or(false);
         let print_sizes = self.print_sizes.unwrap_or(false);
 
-        // Process missing libraries
-        // TODO: skip this if project was not compiled using --detect-missing-libraries
-        let mut missing_libs_unique: HashSet<String> = HashSet::new();
-        for (artifact_id, artifact) in output.artifact_ids() {
-            // TODO: when compiling specific files, the output might still add cached artifacts
-            // that are not part of the file list to the output, which may cause missing libraries
-            // error to trigger for files that were not intended to be compiled.
-            // This behaviour needs to be investigated better on the foundry-compilers side.
-            // For now we filter, checking only the files passed to compile.
-            let is_target_file =
-                self.files.is_empty() || self.files.iter().any(|f| artifact_id.path == *f);
-            if is_target_file {
-                if let Some(mls) = artifact.missing_libraries() {
-                    missing_libs_unique.extend(mls.clone());
-                }
-            }
-        }
-
-        let missing_libs: Vec<ZkMissingLibrary> = missing_libs_unique
-            .into_iter()
-            .map(|ml| {
-                let mut split = ml.split(':');
-                let contract_path =
-                    split.next().expect("Failed to extract contract path for missing library");
-                let contract_name =
-                    split.next().expect("Failed to extract contract name for missing library");
-
-                let mut abs_path_buf = PathBuf::new();
-                abs_path_buf.push(root_path.as_ref());
-                abs_path_buf.push(contract_path);
-
-                let art = output.find(abs_path_buf.as_path(), contract_name).unwrap_or_else(|| {
-                    panic!(
-                        "Could not find contract {contract_name} at path {contract_path} for compilation output"
-                    )
-                });
-
-                ZkMissingLibrary {
-                    contract_path: contract_path.to_string(),
-                    contract_name: contract_name.to_string(),
-                    missing_libraries: art.missing_libraries().cloned().unwrap_or_default(),
-                }
-            })
-            .collect();
-
-        if !missing_libs.is_empty() {
-            libraries::add_dependencies_to_missing_libraries_cache(
-                root_path,
-                missing_libs.as_slice(),
-            )
-            .expect("Error while adding missing libraries");
-            let missing_libs_list = missing_libs
-                .iter()
-                .map(|ml| format!("{}:{}", ml.contract_path, ml.contract_name))
-                .collect::<Vec<String>>()
-                .join(", ");
-            eyre::bail!("Missing libraries detected: {missing_libs_list}\n\nRun the following command in order to deploy each missing library:\n\nforge create <LIBRARY> --private-key <PRIVATE_KEY> --rpc-url <RPC_URL> --chain <CHAIN_ID> --zksync\n\nThen pass the library addresses using the --libraries option");
-        }
-
         // print any sizes or names
         if print_names {
             let mut artifacts: BTreeMap<_, Vec<_>> = BTreeMap::new();

crates/config/src/zksync.rs

@@ -166,6 +166,30 @@ pub fn config_zksolc_settings(config: &Config) -> Result<ZkSolcSettings, SolcErr
     Ok(config.zksync.settings(libraries, config.evm_version, config.via_ir))
 }
 
+/// Return the configured `zksolc` compiler
+///
+/// If not `offline`, will install the default version automatically
+/// Will fallback to `zksolc` present in the environment
+pub fn config_zksolc_compiler(config: &Config) -> Result<ZkSolcCompiler, SolcError> {
+    let zksolc = if let Some(zksolc) =
+        config_ensure_zksolc(config.zksync.zksolc.as_ref(), config.offline)?
+    {
+        zksolc
+    } else if !config.offline {
+        let default_version = semver::Version::new(1, 5, 8);
+        let mut zksolc = ZkSolc::find_installed_version(&default_version)?;
+        if zksolc.is_none() {
+            ZkSolc::blocking_install(&default_version)?;
+            zksolc = ZkSolc::find_installed_version(&default_version)?;
+        }
+        zksolc.unwrap_or_else(|| panic!("Could not install zksolc v{default_version}"))
+    } else {
+        "zksolc".into()
+    };
+
+    Ok(ZkSolcCompiler { zksolc, solc: config_solc_compiler(config)? })
+}
+
 /// Create a new zkSync project
 pub fn config_create_project(
     config: &Config,
@@ -193,23 +217,7 @@ pub fn config_create_project(
         builder = builder.sparse_output(filter);
     }
 
-    let zksolc = if let Some(zksolc) =
-        config_ensure_zksolc(config.zksync.zksolc.as_ref(), config.offline)?
-    {
-        zksolc
-    } else if !config.offline {
-        let default_version = semver::Version::new(1, 5, 7);
-        let mut zksolc = ZkSolc::find_installed_version(&default_version)?;
-        if zksolc.is_none() {
-            ZkSolc::blocking_install(&default_version)?;
-            zksolc = ZkSolc::find_installed_version(&default_version)?;
-        }
-        zksolc.unwrap_or_else(|| panic!("Could not install zksolc v{default_version}"))
-    } else {
-        "zksolc".into()
-    };
-
-    let zksolc_compiler = ZkSolcCompiler { zksolc, solc: config_solc_compiler(config)? };
+    let zksolc_compiler = config_zksolc_compiler(config)?;
 
     let project = builder.build(zksolc_compiler)?;
 
@@ -229,12 +237,12 @@ pub fn config_create_project(
 fn config_solc_compiler(config: &Config) -> Result<SolcCompiler, SolcError> {
     if let Some(path) = &config.zksync.solc_path {
         if !path.is_file() {
-            return Err(SolcError::msg(format!("`solc` {} does not exist", path.display())))
+            return Err(SolcError::msg(format!("`solc` {} does not exist", path.display())));
         }
         let version = get_solc_version_info(path)?.version;
         let solc =
             Solc::new_with_version(path, Version::new(version.major, version.minor, version.patch));
-        return Ok(SolcCompiler::Specific(solc))
+        return Ok(SolcCompiler::Specific(solc));
     }
 
     if let Some(ref solc) = config.solc {
@@ -256,7 +264,7 @@ fn config_solc_compiler(config: &Config) -> Result<SolcCompiler, SolcError> {
             }
             SolcReq::Local(path) => {
                 if !path.is_file() {
-                    return Err(SolcError::msg(format!("`solc` {} does not exist", path.display())))
+                    return Err(SolcError::msg(format!("`solc` {} does not exist", path.display())));
                 }
                 let version = get_solc_version_info(path)?.version;
                 Solc::new_with_version(
@@ -307,7 +315,7 @@ pub fn config_ensure_zksolc(
                     if offline {
                         return Err(SolcError::msg(format!(
                             "can't install missing zksolc {version} in offline mode"
-                        )))
+                        )));
                     }
                     ZkSolc::blocking_install(version)?;
                     zksolc = ZkSolc::find_installed_version(version)?;
@@ -319,12 +327,12 @@ pub fn config_ensure_zksolc(
                     return Err(SolcError::msg(format!(
                         "`zksolc` {} does not exist",
                         zksolc.display()
-                    )))
+                    )));
                 }
                 Some(zksolc.clone())
             }
         };
-        return Ok(zksolc)
+        return Ok(zksolc);
     }
 
     Ok(None)

crates/evm/evm/Cargo.toml

@@ -22,6 +22,7 @@ foundry-evm-core.workspace = true
 foundry-evm-coverage.workspace = true
 foundry-evm-fuzz.workspace = true
 foundry-evm-traces.workspace = true
+foundry-linking.workspace = true
 foundry-zksync-core.workspace = true
 foundry-zksync-compilers.workspace = true
 foundry-zksync-inspectors.workspace = true

crates/evm/evm/src/executors/mod.rs

@@ -40,7 +40,7 @@ use std::{
     borrow::Cow,
     time::{Duration, Instant},
 };
-use strategy::ExecutorStrategy;
+use strategy::{DeployLibKind, DeployLibResult, ExecutorStrategy};
 
 mod builder;
 pub use builder::ExecutorBuilder;
@@ -303,6 +303,23 @@ impl Executor {
         self.deploy_with_env(env, rd)
     }
 
+    /// Deploys a library contract and commits the new state to the underlying database.
+    ///
+    /// Executes a `deploy_kind` transaction with the provided parameters
+    /// and persistent database state modifications.
+    ///
+    /// Will return a list of deployment results and transaction requests
+    /// Will also ensure nonce is increased for the sender
+    pub fn deploy_library(
+        &mut self,
+        from: Address,
+        kind: DeployLibKind,
+        value: U256,
+        rd: Option<&RevertDecoder>,
+    ) -> Result<Vec<DeployLibResult>, EvmError> {
+        self.strategy.runner.deploy_library(self, from, kind, value, rd)
+    }
+
     /// Deploys a contract using the given `env` and commits the new state to the underlying
     /// database.
     ///