feat(resolc): integrate revive compiler for evm to resolc compilation

Cargo.toml

@@ -35,7 +35,10 @@ foundry-compilers = { path = "crates/compilers", version = "0.12.3" }
 foundry-compilers-artifacts = { path = "crates/artifacts/artifacts", version = "0.12.3" }
 foundry-compilers-artifacts-solc = { path = "crates/artifacts/solc", version = "0.12.3" }
 foundry-compilers-artifacts-vyper = { path = "crates/artifacts/vyper", version = "0.12.3" }
+foundry-compilers-artifacts-resolc = { path = "crates/artifacts/resolc", version = "0.12.3" }
 foundry-compilers-core = { path = "crates/core", version = "0.12.3" }
+revive-solidity = { git = "https://github.com/paritytech/revive", tag = "v0.1.0-dev-4", package = "revive-solidity" }
+revive-llvm-context = { git = "https://github.com/paritytech/revive", tag = "v0.1.0-dev-4", package = "revive-llvm-context" }
 
 alloy-json-abi = { version = "0.8", features = ["serde_json"] }
 alloy-primitives = { version = "0.8", features = ["serde", "rand"] }

crates/artifacts/artifacts/Cargo.toml

@@ -17,6 +17,7 @@ workspace = true
 [dependencies]
 foundry-compilers-artifacts-solc.workspace = true
 foundry-compilers-artifacts-vyper.workspace = true
+foundry-compilers-artifacts-resolc.workspace = true
 
 [features]
 async = ["foundry-compilers-artifacts-solc/async"]

crates/artifacts/artifacts/src/lib.rs

@@ -3,6 +3,8 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+pub use foundry_compilers_artifacts_resolc as resolc;
 pub use foundry_compilers_artifacts_solc as solc;
 pub use foundry_compilers_artifacts_vyper as vyper;
+
 pub use solc::*;

crates/artifacts/resolc/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "foundry-compilers-artifacts-resolc"
+description = "Rust bindings for Revive JSON artifacts"
+
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+exclude.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+foundry-compilers-core.workspace = true
+foundry-compilers-artifacts-solc.workspace = true
+
+serde.workspace = true
+semver.workspace = true
+serde_json.workspace = true
+tracing.workspace = true
+alloy-primitives.workspace = true
+alloy-json-abi.workspace = true
+rayon.workspace = true
+thiserror.workspace = true
+md-5.workspace = true
+yansi.workspace = true
+futures-util = { workspace = true, optional = true }
+tokio = { workspace = true, optional = true }
+revive-solidity.workspace = true
+revive-llvm-context.workspace = true
+walkdir = "2.4"
+
+[target.'cfg(windows)'.dependencies]
+path-slash.workspace = true
+
+[dev-dependencies]
+serde_path_to_error = "0.1"
+similar-asserts.workspace = true
+foundry-compilers-core = { workspace = true, features = ["test-utils"] }
+
+[features]
+async = ["dep:tokio", "futures-util", "tokio/fs"]

crates/artifacts/resolc/src/contract.rs

@@ -0,0 +1,161 @@
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashSet},
+};
+
+use alloy_json_abi::JsonAbi;
+use foundry_compilers_artifacts_solc::{
+    CompactBytecode, CompactContractBytecode, CompactContractBytecodeCow, CompactContractRef,
+    CompactDeployedBytecode, DevDoc, StorageLayout, UserDoc,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{ResolcEVM, EVM};
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct ResolcContract {
+    /// The contract ABI.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub abi: Option<JsonAbi>,
+    /// The contract metadata.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+    /// The contract developer documentation.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub devdoc: Option<DevDoc>,
+    /// The contract user documentation.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub userdoc: Option<UserDoc>,
+    /// The contract storage layout.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub storage_layout: Option<StorageLayout>,
+    /// Contract's bytecode and related objects
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub evm: Option<EVM>,
+    /// Revive related output
+    /// We are going to use  structs defined locally
+    /// as opposed to revive defined
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolc_evm: Option<ResolcEVM>,
+    /// The contract optimized IR code.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ir_optimized: Option<String>,
+    /// The contract PolkaVM bytecode hash.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hash: Option<String>,
+    /// The contract factory dependencies.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub factory_dependencies: Option<BTreeMap<String, String>>,
+    /// The contract missing libraries.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub missing_libraries: Option<HashSet<String>>,
+}
+
+impl Default for ResolcContract {
+    fn default() -> Self {
+        Self {
+            abi: None,
+            metadata: None,
+            devdoc: None,
+            userdoc: None,
+            storage_layout: None,
+            evm: None,
+            ir_optimized: None,
+            hash: None,
+            factory_dependencies: None,
+            missing_libraries: None,
+            resolc_evm: None,
+        }
+    }
+}
+
+impl<'a> From<&'a ResolcContract> for CompactContractBytecodeCow<'a> {
+    fn from(value: &'a ResolcContract) -> Self {
+        if let Some((standard_abi, compact_bytecode, compact_deployed_bytecode)) =
+            create_compact_bytecode(value)
+        {
+            Self {
+                abi: Some(Cow::Owned(standard_abi)),
+                bytecode: Some(Cow::Owned(compact_bytecode)),
+                deployed_bytecode: Some(Cow::Owned(compact_deployed_bytecode)),
+            }
+        } else {
+            Self { abi: None, bytecode: None, deployed_bytecode: None }
+        }
+    }
+}
+
+impl From<ResolcContract> for CompactContractBytecode {
+    fn from(value: ResolcContract) -> Self {
+        if let Some((standard_abi, compact_bytecode, compact_deployed_bytecode)) =
+            create_compact_bytecode(&value)
+        {
+            Self {
+                abi: Some(standard_abi),
+                bytecode: Some(compact_bytecode),
+                deployed_bytecode: Some(compact_deployed_bytecode),
+            }
+        } else {
+            Self { abi: None, bytecode: None, deployed_bytecode: None }
+        }
+    }
+}
+
+impl<'a> From<&'a ResolcContract> for CompactContractRef<'a> {
+    fn from(c: &'a ResolcContract) -> Self {
+        let (bin, bin_runtime) = if let Some(ref evm) = c.resolc_evm {
+            (
+                evm.bytecode.as_ref().map(|code| &code.object),
+                evm.deployed_bytecode
+                    .as_ref()
+                    .and_then(|deployed| deployed.bytecode.as_ref().map(|code| &code.object)),
+            )
+        } else {
+            (None, None)
+        };
+
+        Self { abi: c.abi.as_ref(), bin, bin_runtime }
+    }
+}
+fn create_compact_bytecode(
+    parent_contract: &ResolcContract,
+) -> Option<(JsonAbi, CompactBytecode, CompactDeployedBytecode)> {
+    let Some(resolc_evm) = &parent_contract.resolc_evm else {
+        return None;
+    };
+
+    let Some(bytecode) = &resolc_evm.bytecode else {
+        return None;
+    };
+
+    let Some(deployed) = &resolc_evm.deployed_bytecode else {
+        return None;
+    };
+
+    let Some(deployed_bytecode) = &deployed.bytecode else {
+        return None;
+    };
+
+    let compact_bytecode = CompactBytecode {
+        object: bytecode.object.clone(),
+        source_map: None,
+        link_references: BTreeMap::default(),
+    };
+
+    let compact_bytecode_deployed = CompactBytecode {
+        object: deployed_bytecode.object.clone(),
+        source_map: None,
+        link_references: BTreeMap::default(),
+    };
+
+    let compact_deployed_bytecode = CompactDeployedBytecode {
+        bytecode: Some(compact_bytecode_deployed),
+        immutable_references: BTreeMap::default(),
+    };
+
+    Some((
+        parent_contract.abi.clone().unwrap_or_default(),
+        compact_bytecode,
+        compact_deployed_bytecode,
+    ))
+}

crates/artifacts/resolc/src/lib.rs

@@ -0,0 +1,154 @@
+use std::{
+    collections::{BTreeMap, HashSet},
+    path::{Path, PathBuf},
+};
+
+pub mod contract;
+use contract::ResolcContract;
+use foundry_compilers_artifacts_solc::{
+    Bytecode, DeployedBytecode, Error, FileToContractsMap, SourceFile, SourceFiles,
+};
+use serde::{Deserialize, Serialize};
+
+/// This file contains data structures that we need defined locally as some of them need to be used in trait
+/// Implementation in such a way that they are owned so if we use existing structures from Revive
+/// We will run into issues
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Default)]
+pub struct ResolcCompilerOutput {
+    /// The file-contract hashmap.
+    #[serde(default)]
+    pub contracts: FileToContractsMap<ResolcContract>,
+    /// The source code mapping data.
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub sources: BTreeMap<PathBuf, SourceFile>,
+    /// The compilation errors and warnings.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub errors: Vec<Error>,
+    /// The `solc` compiler version.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    /// The `solc` compiler long version.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub long_version: Option<String>,
+    /// The `resolc` compiler version.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub revive_version: Option<String>,
+}
+#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecursiveFunction {
+    /// The function name.
+    pub name: String,
+    /// The creation code function block tag.
+    pub creation_tag: Option<usize>,
+    /// The runtime code function block tag.
+    pub runtime_tag: Option<usize>,
+    /// The number of input arguments.
+    #[serde(rename = "totalParamSize")]
+    pub input_size: usize,
+    /// The number of output arguments.
+    #[serde(rename = "totalRetParamSize")]
+    pub output_size: usize,
+}
+#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtraMetadata {
+    /// The list of recursive functions.
+    #[serde(default = "Vec::new")]
+    pub recursive_functions: Vec<RecursiveFunction>,
+}
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Default)]
+pub struct ResolcEVM {
+    /// The contract EVM legacy assembly code.
+    #[serde(rename = "legacyAssembly", skip_serializing_if = "Option::is_none")]
+    pub assembly: Option<serde_json::Value>,
+    /// The contract PolkaVM assembly code.
+    #[serde(rename = "assembly", skip_serializing_if = "Option::is_none")]
+    pub assembly_text: Option<String>,
+    /// The contract bytecode.
+    /// Is reset by that of PolkaVM before yielding the compiled project artifacts.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bytecode: Option<Bytecode>,
+    /// The deployed bytecode of the contract.
+    /// It is overwritten with the PolkaVM blob before yielding the compiled project artifacts.
+    /// Hence it will be the same as the runtime code but we keep both for compatibility reasons.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deployed_bytecode: Option<DeployedBytecode>,
+    /// The contract function signatures.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub method_identifiers: Option<BTreeMap<String, String>>,
+    /// The extra EVMLA metadata.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extra_metadata: Option<ExtraMetadata>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EVM {
+    /// The contract EraVM assembly code.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assembly: Option<String>,
+    /// The contract EVM legacy assembly code.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub legacy_assembly: Option<serde_json::Value>,
+    /// The contract bytecode.
+    /// Is reset by that of EraVM before yielding the compiled project artifacts.
+    pub bytecode: Option<Bytecode>,
+    /// The list of function hashes
+    #[serde(default, skip_serializing_if = "::std::collections::BTreeMap::is_empty")]
+    pub method_identifiers: BTreeMap<String, String>,
+    /// The extra EVMLA metadata.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extra_metadata: Option<ExtraMetadata>,
+}
+pub type ResolcContracts = FileToContractsMap<ResolcContract>;
+
+/// A wrapper helper type for the `Contracts` type alias
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct OutputContracts(pub ResolcContracts);
+impl ResolcCompilerOutput {
+    /// Whether the output contains a compiler error
+    pub fn has_error(&self) -> bool {
+        self.errors.iter().any(|err| err.severity.is_error())
+    }
+
+    /// Returns the output's source files and contracts separately, wrapped in helper types that
+    /// provide several helper methods
+    pub fn split(self) -> (SourceFiles, OutputContracts) {
+        (SourceFiles(self.sources), OutputContracts(self.contracts))
+    }
+
+    /// Retains only those files the given iterator yields
+    ///
+    /// In other words, removes all contracts for files not included in the iterator
+    pub fn retain_files<'a, I>(&mut self, files: I)
+    where
+        I: IntoIterator<Item = &'a Path>,
+    {
+        // Note: use `to_lowercase` here because solc not necessarily emits the exact file name,
+        // e.g. `src/utils/upgradeProxy.sol` is emitted as `src/utils/UpgradeProxy.sol`
+        let files: HashSet<_> =
+            files.into_iter().map(|s| s.to_string_lossy().to_lowercase()).collect();
+        self.contracts.retain(|f, _| files.contains(&f.to_string_lossy().to_lowercase()));
+        self.sources.retain(|f, _| files.contains(&f.to_string_lossy().to_lowercase()));
+    }
+
+    pub fn merge(&mut self, other: Self) {
+        self.errors.extend(other.errors);
+        self.contracts.extend(other.contracts);
+        self.sources.extend(other.sources);
+    }
+
+    pub fn join_all(&mut self, root: impl AsRef<Path>) {
+        let root = root.as_ref();
+        self.contracts = std::mem::take(&mut self.contracts)
+            .into_iter()
+            .map(|(path, contracts)| (root.join(path), contracts))
+            .collect();
+        self.sources = std::mem::take(&mut self.sources)
+            .into_iter()
+            .map(|(path, source)| (root.join(path), source))
+            .collect();
+    }
+}