feat: syncs EVM functionality with solx (#305)

Author: hedgar2017

Cargo.lock

@@ -13,4 +13,4 @@ authors = [
 ]
 license = "MIT OR Apache-2.0"
 edition = "2021"
-version = "1.5.13"
+version = "1.5.14"

Cargo.toml

@@ -4,7 +4,6 @@
 
 pub mod object;
 
-use std::collections::BTreeSet;
 use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
@@ -26,10 +25,6 @@ pub struct Contract {
     pub metadata_hash: Option<era_compiler_common::Hash>,
     /// The metadata JSON.
     pub metadata_json: serde_json::Value,
-    /// The unlinked missing libraries.
-    pub missing_libraries: BTreeSet<String>,
-    /// The binary object format.
-    pub object_format: era_compiler_common::ObjectFormat,
 }
 
 impl Contract {
@@ -42,17 +37,13 @@ impl Contract {
         runtime_object: Object,
         metadata_hash: Option<era_compiler_common::Hash>,
         metadata_json: serde_json::Value,
-        missing_libraries: BTreeSet<String>,
-        object_format: era_compiler_common::ObjectFormat,
     ) -> Self {
         Self {
             name,
             deploy_object,
             runtime_object,
             metadata_hash,
             metadata_json,
-            missing_libraries,
-            object_format,
         }
     }
 
@@ -63,13 +54,9 @@ impl Contract {
         self,
         path: String,
         output_metadata: bool,
-        output_assembly: bool,
         output_binary: bool,
     ) -> anyhow::Result<()> {
         writeln!(std::io::stdout(), "\n======= {path} =======")?;
-        if output_assembly {
-            writeln!(std::io::stdout(), "Assembly:\nComing soon")?;
-        }
         if output_metadata {
             writeln!(std::io::stdout(), "Metadata:\n{}", self.metadata_json)?;
         }
@@ -92,7 +79,6 @@ impl Contract {
         self,
         output_path: &Path,
         output_metadata: bool,
-        output_assembly: bool,
         output_binary: bool,
         overwrite: bool,
     ) -> anyhow::Result<()> {
@@ -129,25 +115,6 @@ impl Contract {
             }
         }
 
-        if output_assembly {
-            let output_name = format!(
-                "{}.{}",
-                self.name.name.as_deref().unwrap_or(file_name),
-                "asm"
-            );
-            let mut output_path = output_path.clone();
-            output_path.push(output_name.as_str());
-
-            if output_path.exists() && !overwrite {
-                anyhow::bail!(
-                    "Refusing to overwrite an existing file {output_path:?} (use --overwrite to force)."
-                );
-            } else {
-                std::fs::write(output_path.as_path(), "Coming soon".as_bytes())
-                    .map_err(|error| anyhow::anyhow!("File {output_path:?} writing: {error}"))?;
-            }
-        }
-
         if output_binary {
             let output_name = format!(
                 "{}.{}",
@@ -186,8 +153,11 @@ impl Contract {
             .modify_evm(hex::encode(self.deploy_object.bytecode));
         standard_json_contract
             .missing_libraries
-            .extend(self.missing_libraries);
-        standard_json_contract.object_format = Some(self.object_format);
+            .extend(self.deploy_object.unlinked_libraries);
+        standard_json_contract
+            .missing_libraries
+            .extend(self.runtime_object.unlinked_libraries);
+        standard_json_contract.object_format = Some(self.deploy_object.format);
 
         Ok(())
     }
@@ -208,8 +178,11 @@ impl Contract {
 
         combined_json_contract
             .missing_libraries
-            .extend(self.missing_libraries);
-        combined_json_contract.object_format = Some(self.object_format);
+            .extend(self.deploy_object.unlinked_libraries);
+        combined_json_contract
+            .missing_libraries
+            .extend(self.runtime_object.unlinked_libraries);
+        combined_json_contract.object_format = Some(self.deploy_object.format);
 
         Ok(())
     }

era-compiler-solidity/src/build_evm/contract/mod.rs

@@ -2,6 +2,9 @@
 //! Bytecode object.
 //!
 
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+
 ///
 /// Bytecode object.
 ///
@@ -21,11 +24,13 @@ pub struct Object {
     pub code_segment: era_compiler_common::CodeSegment,
     /// Dependencies.
     pub dependencies: era_yul::Dependencies,
+    /// The unlinked unlinked libraries.
+    pub unlinked_libraries: BTreeSet<String>,
     /// Whether the object is already assembled.
     pub is_assembled: bool,
-    /// The binary object format.
-    pub object_format: era_compiler_common::ObjectFormat,
-    /// Warnings produced during compilation.
+    /// Binary object format.
+    pub format: era_compiler_common::ObjectFormat,
+    /// Compilation warnings.
     pub warnings: Vec<era_compiler_llvm_context::EVMWarning>,
 }
 
@@ -40,6 +45,8 @@ impl Object {
         codegen: Option<era_solc::StandardJsonInputCodegen>,
         code_segment: era_compiler_common::CodeSegment,
         dependencies: era_yul::Dependencies,
+        unlinked_libraries: BTreeSet<String>,
+        format: era_compiler_common::ObjectFormat,
         warnings: Vec<era_compiler_llvm_context::EVMWarning>,
     ) -> Self {
         Self {
@@ -49,33 +56,63 @@ impl Object {
             codegen,
             code_segment,
             dependencies,
+            unlinked_libraries,
             is_assembled: false,
-            object_format: era_compiler_common::ObjectFormat::ELF,
+            format,
             warnings,
         }
     }
 
     ///
-    /// Whether the object requires assebmling with its dependencies.
+    /// Links the object with its linker symbols.
     ///
-    pub fn requires_assembling(&self) -> bool {
-        !self.is_assembled && !self.dependencies.inner.is_empty()
+    pub fn link(
+        &mut self,
+        linker_symbols: &BTreeMap<String, [u8; era_compiler_common::BYTE_LENGTH_ETH_ADDRESS]>,
+    ) -> anyhow::Result<()> {
+        let memory_buffer = inkwell::memory_buffer::MemoryBuffer::create_from_memory_range(
+            self.bytecode.as_slice(),
+            self.identifier.as_str(),
+            false,
+        );
+
+        let (linked_object, object_format) =
+            era_compiler_llvm_context::evm_link(memory_buffer, linker_symbols)?;
+        self.format = object_format;
+
+        self.bytecode = linked_object.as_slice().to_owned();
+        // if let era_compiler_common::CodeSegment::Deploy = self.code_segment {
+        //     let metadata = match contract.metadata_hash {
+        //         Some(era_compiler_common::Hash::IPFS(ref hash)) => {
+        //             let cbor = era_compiler_common::CBOR::new(
+        //                 Some((
+        //                     era_compiler_common::EVMMetadataHashType::IPFS,
+        //                     hash.as_bytes(),
+        //                 )),
+        //                 crate::r#const::SOLC_PRODUCTION_NAME.to_owned(),
+        //                 cbor_data.clone(),
+        //             );
+        //             cbor.to_vec()
+        //         }
+        //         Some(era_compiler_common::Hash::Keccak256(ref hash)) => hash.to_vec(),
+        //         None => {
+        //             let cbor = era_compiler_common::CBOR::<'_, String>::new(
+        //                 None,
+        //                 crate::r#const::SOLC_PRODUCTION_NAME.to_owned(),
+        //                 cbor_data.clone(),
+        //             );
+        //             cbor.to_vec()
+        //         }
+        //     };
+        //     self.bytecode.extend(metadata);
+        // }
+        Ok(())
     }
 
     ///
-    /// Checks whether the object name matches a dot-separated dependency name.
-    ///
-    /// This function is only useful for Yul codegen where object names like `A_25.A_25_deployed` are found.
-    /// For EVM assembly codegen, it performs a simple comparison.
+    /// Whether the object requires assebmling with its dependencies.
     ///
-    pub fn matches_dependency(&self, dependency: &str) -> bool {
-        let dependency = match self.codegen {
-            Some(era_solc::StandardJsonInputCodegen::EVMLA) | None => dependency,
-            Some(era_solc::StandardJsonInputCodegen::Yul) => {
-                dependency.split('.').last().expect("Always exists")
-            }
-        };
-
-        self.identifier.as_str() == dependency
+    pub fn requires_assembling(&self) -> bool {
+        !self.is_assembled && !self.dependencies.inner.is_empty()
     }
 }