fix: change contract metadata from JSON to string

hedgar2017 · hedgar2017 · commit c65a63f49e21 · 2025-03-22T03:32:41.000+08:00
diff --git a/llvm b/llvm
@@ -1 +1 @@
-Subproject commit e5381da9c19752427700b7c504b68f2c8fee914e
+Subproject commit 35492c52530c00e9b43d45fc1c0c6894b7d93a79
diff --git a/solx-solc/src/solc.rs b/solx-solc/src/solc.rs
@@ -105,7 +105,7 @@ impl Compiler {
 
         let mut error_message = std::ptr::null_mut();
         let error_pointer = &mut error_message;
-        let output_ffi = unsafe {
+        let output_string = unsafe {
             let output_pointer = solidity_compile_default_callback(
                 input_c_string.as_ptr(),
                 base_path,
@@ -125,7 +125,7 @@ impl Compiler {
         };
 
         let mut solc_output = match era_compiler_common::deserialize_from_str::<StandardJsonOutput>(
-            output_ffi.as_str(),
+            output_string.as_str(),
         ) {
             Ok(solc_output) => solc_output,
             Err(error) => {
diff --git a/solx-solc/src/standard_json/input/settings/metadata.rs b/solx-solc/src/standard_json/input/settings/metadata.rs
@@ -11,19 +11,14 @@ pub struct Metadata {
     /// Whether to use literal content.
     #[serde(default)]
     pub use_literal_content: bool,
-
     /// The metadata hash type.
-    #[serde(
-        alias = "bytecodeHash",
-        default = "Metadata::default_hash_type",
-        skip_serializing
-    )]
-    pub hash_type: era_compiler_common::HashType,
+    #[serde(default = "Metadata::default_bytecode_hash", skip_serializing)]
+    pub bytecode_hash: era_compiler_common::HashType,
 }
 
 impl Default for Metadata {
     fn default() -> Self {
-        Self::new(false, Self::default_hash_type())
+        Self::new(false, Self::default_bytecode_hash())
     }
 }
 
@@ -33,15 +28,15 @@ impl Metadata {
     ///
     pub fn new(use_literal_content: bool, hash_type: era_compiler_common::HashType) -> Self {
         Self {
-            hash_type,
+            bytecode_hash: hash_type,
             use_literal_content,
         }
     }
 
     ///
     /// The default metadata hash type.
     ///
-    fn default_hash_type() -> era_compiler_common::HashType {
-        era_compiler_common::HashType::Keccak256
+    fn default_bytecode_hash() -> era_compiler_common::HashType {
+        era_compiler_common::HashType::Ipfs
     }
 }
diff --git a/solx-solc/src/standard_json/input/settings/mod.rs b/solx-solc/src/standard_json/input/settings/mod.rs
@@ -50,7 +50,7 @@ pub struct Settings {
     pub metadata: Metadata,
 
     /// The extra LLVM options.
-    #[serde(default, rename = "LLVMOptions", skip_serializing)]
+    #[serde(default, skip_serializing)]
     pub llvm_options: Vec<String>,
 }
 
diff --git a/solx-solc/src/standard_json/input/settings/selection/file.rs b/solx-solc/src/standard_json/input/settings/selection/file.rs
@@ -58,13 +58,8 @@ impl File {
     /// Afterwards, the flags are used to prune JSON output before returning it.
     ///
     pub fn selection_to_prune(&self) -> Self {
-        let required_per_file = vec![Selector::AST];
-        let required_per_contract = vec![
-            Selector::MethodIdentifiers,
-            Selector::Metadata,
-            Selector::Yul,
-            Selector::EVMLA,
-        ];
+        let required_per_file = vec![];
+        let required_per_contract = vec![Selector::Yul, Selector::EVMLA];
 
         let mut unset_per_file = HashSet::with_capacity(required_per_file.len());
         let mut unset_per_contract = HashSet::with_capacity(required_per_contract.len());
diff --git a/solx-solc/src/standard_json/input/settings/selection/mod.rs b/solx-solc/src/standard_json/input/settings/selection/mod.rs
@@ -32,12 +32,7 @@ impl Selection {
     /// Creates the selection required by EraVM compilation process.
     ///
     pub fn new_required(via_ir: bool) -> Self {
-        Self::new(vec![
-            Selector::AST,
-            Selector::MethodIdentifiers,
-            Selector::Metadata,
-            via_ir.into(),
-        ])
+        Self::new(vec![via_ir.into(), Selector::ABI]) // TODO: investigate why ABI is required
     }
 
     ///
diff --git a/solx-solc/src/standard_json/output/contract/mod.rs b/solx-solc/src/standard_json/output/contract/mod.rs
@@ -25,8 +25,8 @@ pub struct Contract {
     #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
     pub transient_storage_layout: serde_json::Value,
     /// The contract metadata.
-    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
-    pub metadata: serde_json::Value,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub metadata: String,
     /// The contract developer documentation.
     #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
     pub devdoc: serde_json::Value,
@@ -41,16 +41,28 @@ pub struct Contract {
     pub evm: Option<EVM>,
 
     /// Unlinked factory dependencies.
-    #[serde(default, skip_deserializing)]
+    #[serde(
+        default,
+        skip_serializing_if = "BTreeSet::is_empty",
+        skip_deserializing
+    )]
     pub factory_dependencies_unlinked: BTreeSet<String>,
     /// Linked factory dependencies.
-    #[serde(default, skip_deserializing)]
+    #[serde(
+        default,
+        skip_serializing_if = "BTreeMap::is_empty",
+        skip_deserializing
+    )]
     pub factory_dependencies: BTreeMap<String, String>,
     /// Missing linkable libraries.
-    #[serde(default, skip_deserializing)]
+    #[serde(
+        default,
+        skip_serializing_if = "BTreeSet::is_empty",
+        skip_deserializing
+    )]
     pub missing_libraries: BTreeSet<String>,
     /// Binary object format.
-    #[serde(default, skip_deserializing)]
+    #[serde(default, skip_serializing_if = "Option::is_none", skip_deserializing)]
     pub object_format: Option<era_compiler_common::ObjectFormat>,
 }
 
@@ -62,7 +74,7 @@ impl Contract {
         self.abi.is_null()
             && self.storage_layout.is_null()
             && self.transient_storage_layout.is_null()
-            && self.metadata.is_null()
+            && self.metadata.is_empty()
             && self.devdoc.is_null()
             && self.userdoc.is_null()
             && self.ir_optimized.is_empty()
diff --git a/solx-solc/src/standard_json/output/mod.rs b/solx-solc/src/standard_json/output/mod.rs
@@ -96,32 +96,20 @@ impl Output {
     /// Prunes the output JSON and prints it to stdout.
     ///
     pub fn write_and_exit(mut self, selection_to_prune: Selection) -> ! {
-        let sources = self.sources.values_mut().collect::<Vec<&mut Source>>();
-        for source in sources.into_iter() {
-            if selection_to_prune.contains(&Selector::AST) {
-                source.ast = None;
-            }
-        }
-
         let contracts = self
             .contracts
             .values_mut()
             .flat_map(|contracts| contracts.values_mut())
             .collect::<Vec<&mut Contract>>();
         for contract in contracts.into_iter() {
-            if selection_to_prune.contains(&Selector::Metadata) {
-                contract.metadata = serde_json::Value::Null;
-            }
+            contract.metadata = String::new(); // TODO: fix metadata
             if selection_to_prune.contains(&Selector::Yul) {
                 contract.ir_optimized = String::new();
             }
             if let Some(ref mut evm) = contract.evm {
                 if selection_to_prune.contains(&Selector::EVMLA) {
                     evm.legacy_assembly = serde_json::Value::Null;
                 }
-                if selection_to_prune.contains(&Selector::MethodIdentifiers) {
-                    evm.method_identifiers.clear();
-                }
             }
         }
 
diff --git a/solx/src/build_evm/contract/mod.rs b/solx/src/build_evm/contract/mod.rs
@@ -24,8 +24,8 @@ pub struct Contract {
     pub runtime_object: Object,
     /// The metadata hash.
     pub metadata_hash: Option<era_compiler_common::Hash>,
-    /// The metadata JSON.
-    pub metadata_json: serde_json::Value,
+    /// The metadata string.
+    pub metadata_string: String,
     /// The unlinked missing libraries.
     pub missing_libraries: BTreeSet<String>,
     /// The binary object format.
@@ -41,7 +41,7 @@ impl Contract {
         deploy_object: Object,
         runtime_object: Object,
         metadata_hash: Option<era_compiler_common::Hash>,
-        metadata_json: serde_json::Value,
+        metadata_string: String,
         missing_libraries: BTreeSet<String>,
         object_format: era_compiler_common::ObjectFormat,
     ) -> Self {
@@ -50,7 +50,7 @@ impl Contract {
             deploy_object,
             runtime_object,
             metadata_hash,
-            metadata_json,
+            metadata_string,
             missing_libraries,
             object_format,
         }
@@ -67,7 +67,7 @@ impl Contract {
     ) -> anyhow::Result<()> {
         writeln!(std::io::stdout(), "\n======= {path} =======")?;
         if output_metadata {
-            writeln!(std::io::stdout(), "Metadata:\n{}", self.metadata_json)?;
+            writeln!(std::io::stdout(), "Metadata:\n{}", self.metadata_string)?;
         }
         if output_binary {
             writeln!(
@@ -118,7 +118,7 @@ impl Contract {
             } else {
                 std::fs::write(
                     output_path.as_path(),
-                    self.metadata_json.to_string().as_bytes(),
+                    self.metadata_string.to_string().as_bytes(),
                 )
                 .map_err(|error| anyhow::anyhow!("File {output_path:?} writing: {error}"))?;
             }
@@ -155,7 +155,7 @@ impl Contract {
         self,
         standard_json_contract: &mut solx_solc::StandardJsonOutputContract,
     ) -> anyhow::Result<()> {
-        standard_json_contract.metadata = self.metadata_json;
+        standard_json_contract.metadata = self.metadata_string;
         standard_json_contract
             .evm
             .get_or_insert_with(solx_solc::StandardJsonOutputContractEVM::default)
diff --git a/solx/src/evmla/assembly/instruction/mod.rs b/solx/src/evmla/assembly/instruction/mod.rs
@@ -137,8 +137,8 @@ impl Instruction {
             Name::PUSH => 1,
             Name::PUSH_Data => 1,
             Name::PUSH_Tag => 1,
-            Name::PUSH_ContractHash => 1,
-            Name::PUSH_ContractHashSize => 1,
+            Name::PUSH_DataOffset => 1,
+            Name::PUSH_DataSize => 1,
             Name::PUSHLIB => 1,
             Name::PUSHDEPLOYADDRESS => 1,
 
@@ -286,7 +286,7 @@ impl Instruction {
         for instruction in instructions.iter_mut() {
             match instruction {
                 Instruction {
-                    name: Name::PUSH_ContractHash | Name::PUSH_ContractHashSize,
+                    name: Name::PUSH_DataOffset | Name::PUSH_DataSize,
                     value: Some(value),
                     ..
                 } => {
diff --git a/solx/src/evmla/assembly/instruction/name.rs b/solx/src/evmla/assembly/instruction/name.rs
@@ -15,12 +15,12 @@ pub enum Name {
     /// Pushes an unknown `data` value.
     #[serde(rename = "PUSH data")]
     PUSH_Data,
-    /// Pushes a contract hash size.
+    /// Pushes a data size.
     #[serde(rename = "PUSH #[$]")]
-    PUSH_ContractHashSize,
-    /// Pushes a contract hash.
+    PUSH_DataSize,
+    /// Pushes a data offset.
     #[serde(rename = "PUSH [$]")]
-    PUSH_ContractHash,
+    PUSH_DataOffset,
 
     /// The eponymous EVM instruction.
     PUSH1,
diff --git a/solx/src/evmla/assembly/mod.rs b/solx/src/evmla/assembly/mod.rs
@@ -135,7 +135,7 @@ impl Assembly {
         if let Some(code) = self.code.as_ref() {
             for instruction in code.iter() {
                 match instruction.name {
-                    InstructionName::PUSH_ContractHash | InstructionName::PUSH_ContractHashSize => {
+                    InstructionName::PUSH_DataOffset | InstructionName::PUSH_DataSize => {
                         let dependency = instruction.value.to_owned().expect("Always exists");
                         let is_runtime_code = dependencies.identifier
                             == dependency
diff --git a/solx/src/evmla/ethereal_ir/function/block/element/mod.rs b/solx/src/evmla/ethereal_ir/function/block/element/mod.rs
@@ -127,15 +127,15 @@ impl era_compiler_llvm_context::EVMWriteLLVM for Element {
                     .ok_or_else(|| anyhow::anyhow!("Instruction value missing"))?,
             )
             .map(Some),
-            InstructionName::PUSH_ContractHash => {
+            InstructionName::PUSH_DataOffset => {
                 let object_name = self
                     .instruction
                     .value
                     .ok_or_else(|| anyhow::anyhow!("Data offset identifier is missing"))?;
                 era_compiler_llvm_context::evm_code::data_offset(context, object_name.as_str())
                     .map(Some)
             }
-            InstructionName::PUSH_ContractHashSize => {
+            InstructionName::PUSH_DataSize => {
                 let object_name = self
                     .instruction
                     .value
diff --git a/solx/src/evmla/ethereal_ir/function/mod.rs b/solx/src/evmla/ethereal_ir/function/mod.rs
@@ -608,8 +608,8 @@ impl Function {
             ),
             Instruction {
                 name:
-                    InstructionName::PUSH_ContractHash
-                    | InstructionName::PUSH_ContractHashSize
+                    InstructionName::PUSH_DataOffset
+                    | InstructionName::PUSH_DataSize
                     | InstructionName::PUSHLIB,
                 value: Some(ref path),
                 ..
diff --git a/solx/src/lib.rs b/solx/src/lib.rs
@@ -203,7 +203,7 @@ pub fn standard_json_evm(
     }
     let llvm_options = solc_input.settings.llvm_options.clone();
 
-    let metadata_hash_type = solc_input.settings.metadata.hash_type;
+    let metadata_hash_type = solc_input.settings.metadata.bytecode_hash;
 
     let (mut solc_output, project) = match language {
         solx_solc::StandardJsonInputLanguage::Solidity => {
diff --git a/solx/src/project/contract/metadata.rs b/solx/src/project/contract/metadata.rs
@@ -9,8 +9,8 @@
 ///
 #[derive(Debug, serde::Serialize)]
 pub struct Metadata<'a> {
-    /// The source code metadata.
-    pub source_metadata: serde_json::Value,
+    /// The original `solc` metadata.
+    pub source_metadata: String,
     /// The `solc` version.
     pub solc_version: semver::Version,
     /// The LLVM `solc` edition.
@@ -28,19 +28,12 @@ impl<'a> Metadata<'a> {
     /// A shortcut constructor.
     ///
     pub fn new(
-        source_metadata: serde_json::Value,
+        source_metadata: String,
         solc_version: semver::Version,
         solc_llvm_edition: semver::Version,
         optimizer_settings: era_compiler_llvm_context::OptimizerSettings,
         llvm_options: &'a [String],
     ) -> Self {
-        let source_metadata = match source_metadata {
-            serde_json::Value::String(inner) => {
-                let value = serde_json::from_str(inner.as_str()).expect("Always valid");
-                serde_json::Value::Object(value)
-            }
-            value => value,
-        };
         Self {
             source_metadata,
             solc_version,
diff --git a/solx/src/project/contract/mod.rs b/solx/src/project/contract/mod.rs
diff --git a/solx/src/project/mod.rs b/solx/src/project/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -11,19 +11,14 @@ pub struct Metadata {`
`11`	`11`	`/// Whether to use literal content.`
`12`	`12`	`#[serde(default)]`
`13`	`13`	`pub use_literal_content: bool,`
`14`		`-`
`15`	`14`	`/// The metadata hash type.`
`16`		`- #[serde(`
`17`		`- alias = "bytecodeHash",`
`18`		`- default = "Metadata::default_hash_type",`
`19`		`- skip_serializing`
`20`		`- )]`
`21`		`- pub hash_type: era_compiler_common::HashType,`
	`15`	`+ #[serde(default = "Metadata::default_bytecode_hash", skip_serializing)]`
	`16`	`+ pub bytecode_hash: era_compiler_common::HashType,`
`22`	`17`	`}`
`23`	`18`
`24`	`19`	`impl Default for Metadata {`
`25`	`20`	`fn default() -> Self {`
`26`		`- Self::new(false, Self::default_hash_type())`
	`21`	`+ Self::new(false, Self::default_bytecode_hash())`
`27`	`22`	`}`
`28`	`23`	`}`
`29`	`24`
`@@ -33,15 +28,15 @@ impl Metadata {`
`33`	`28`	`///`
`34`	`29`	`pub fn new(use_literal_content: bool, hash_type: era_compiler_common::HashType) -> Self {`
`35`	`30`	`Self {`
`36`		`- hash_type,`
	`31`	`+ bytecode_hash: hash_type,`
`37`	`32`	`use_literal_content,`
`38`	`33`	`}`
`39`	`34`	`}`
`40`	`35`
`41`	`36`	`///`
`42`	`37`	`/// The default metadata hash type.`
`43`	`38`	`///`
`44`		`- fn default_hash_type() -> era_compiler_common::HashType {`
`45`		`- era_compiler_common::HashType::Keccak256`
	`39`	`+ fn default_bytecode_hash() -> era_compiler_common::HashType {`
	`40`	`+ era_compiler_common::HashType::Ipfs`
`46`	`41`	`}`
`47`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ pub struct Settings {`
`50`	`50`	`pub metadata: Metadata,`
`51`	`51`
`52`	`52`	`/// The extra LLVM options.`
`53`		`- #[serde(default, rename = "LLVMOptions", skip_serializing)]`
	`53`	`+ #[serde(default, skip_serializing)]`
`54`	`54`	`pub llvm_options: Vec<String>,`
`55`	`55`	`}`
`56`	`56`