Add generation of ABI meta for types generation

* add generate_abi_meta() both for `CompiledProgram` and `TemplateProgram`
* add additional field in cli for printing such output

Author: ikripaka

src/lib.rs

@@ -89,6 +89,14 @@ impl TemplateProgram {
             debug_symbols: self.simfony.debug_symbols(self.file.as_ref()),
             simplicity: commit,
             witness_types: self.simfony.witness_types().shallow_clone(),
+            parameter_types: self.simfony.parameters().shallow_clone(),
+        })
+    }
+
+    pub fn generate_abi_meta(&self) -> Result<AbiMeta, String> {
+        Ok(AbiMeta {
+            witness_types: self.simfony.witness_types().shallow_clone(),
+            param_types: self.parameters().shallow_clone(),
         })
     }
 }
@@ -99,6 +107,7 @@ pub struct CompiledProgram {
     simplicity: Arc<named::CommitNode<Elements>>,
     witness_types: WitnessTypes,
     debug_symbols: DebugSymbols,
+    parameter_types: Parameters,
 }
 
 impl CompiledProgram {
@@ -162,6 +171,19 @@ impl CompiledProgram {
             debug_symbols: self.debug_symbols.clone(),
         })
     }
+
+    pub fn generate_abi_meta(&self) -> Result<AbiMeta, String> {
+        Ok(AbiMeta {
+            witness_types: self.witness_types.shallow_clone(),
+            param_types: self.parameter_types.shallow_clone(),
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct AbiMeta {
+    pub witness_types: WitnessTypes,
+    pub param_types: Parameters,
 }
 
 /// A SimplicityHL program, compiled to Simplicity and satisfied with witness data.

src/main.rs

@@ -2,7 +2,7 @@ use base64::display::Base64Display;
 use base64::engine::general_purpose::STANDARD;
 use clap::{Arg, ArgAction, Command};
 
-use simplicityhl::{Arguments, CompiledProgram};
+use simplicityhl::{AbiMeta, Arguments, CompiledProgram};
 use std::{env, fmt};
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
@@ -12,6 +12,9 @@ struct Output {
     program: String,
     /// Simplicity witness result, base64 encoded, if the .wit file was provided.
     witness: Option<String>,
+    /// Simplicity program ABI metadata to the program which the user provides.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    abi_meta: Option<AbiMeta>,
 }
 
 impl fmt::Display for Output {
@@ -20,6 +23,9 @@ impl fmt::Display for Output {
         if let Some(witness) = &self.witness {
             writeln!(f, "Witness:\n{}", witness)?;
         }
+        if let Some(witness) = &self.abi_meta {
+            writeln!(f, "ABI meta:\n{:?}", witness)?;
+        }
         Ok(())
     }
 }
@@ -59,6 +65,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .action(ArgAction::SetTrue)
                     .help("Output in JSON"),
             )
+            .arg(
+                Arg::new("abi")
+                    .long("abi")
+                    .action(ArgAction::SetTrue)
+                    .help("Additional ABI .simf contract types"),
+            )
     };
 
     let matches = command.get_matches();
@@ -68,6 +80,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let prog_text = std::fs::read_to_string(prog_path).map_err(|e| e.to_string())?;
     let include_debug_symbols = matches.get_flag("debug");
     let output_json = matches.get_flag("json");
+    let abi_param = matches.get_flag("abi");
 
     let compiled = CompiledProgram::new(prog_text, Arguments::default(), include_debug_symbols)?;
 
@@ -103,9 +116,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
+    let abi_opt = if abi_param {
+        Some(compiled.generate_abi_meta()?)
+    } else {
+        None
+    };
+
     let output = Output {
         program: Base64Display::new(&program_bytes, &STANDARD).to_string(),
         witness: witness_bytes.map(|bytes| Base64Display::new(&bytes, &STANDARD).to_string()),
+        abi_meta: abi_opt,
     };
 
     if output_json {

src/serde.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
 use std::fmt;
 
-use serde::{de, ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
-
 use crate::parse::ParseFromStr;
 use crate::str::WitnessName;
 use crate::types::ResolvedType;
 use crate::value::Value;
 use crate::witness::{Arguments, WitnessValues};
+use crate::AbiMeta;
+use serde::{de, ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
 
 struct WitnessMapVisitor;
 
@@ -43,6 +43,32 @@ impl<'de> Deserialize<'de> for WitnessValues {
     }
 }
 
+impl Serialize for AbiMeta {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ::serde::Serializer,
+    {
+        use ::serde::ser::SerializeStruct;
+        use std::collections::HashMap;
+
+        let mut state = serializer.serialize_struct("AbiMeta", 2)?;
+
+        let witness_types_converted = self
+            .witness_types
+            .iter()
+            .map(|(w_name, w_type)| (w_name.to_string(), w_type.to_string()))
+            .collect::<HashMap<_, _>>();
+        state.serialize_field("witness_types", &witness_types_converted)?;
+        let witness_types_converted = self
+            .param_types
+            .iter()
+            .map(|(w_name, w_type)| (w_name.to_string(), w_type.to_string()))
+            .collect::<HashMap<_, _>>();
+        state.serialize_field("parameter_types", &witness_types_converted)?;
+        state.end()
+    }
+}
+
 impl<'de> Deserialize<'de> for Arguments {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where