feat(cli): resolve witness and argument files against the program

Author: KyrylR

examples/p2pk.args

@@ -1,6 +1,3 @@
 {
-    "ALICE_PUBLIC_KEY": {
-        "value": "0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        "type": "Pubkey"
-    }
+    "ALICE_PUBLIC_KEY": "0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
 }

examples/p2pk.wit

@@ -1,6 +1,3 @@
 {
-    "ALICE_SIGNATURE": {
-        "value": "0xf74b3ca574647f8595624b129324afa2f38b598a9c1c7cfc5f08a9c036ec5acd3c0fbb9ed3dae5ca23a0a65a34b5d6cccdd6ba248985d6041f7b21262b17af6f",
-        "type": "Signature"
-    }
+    "ALICE_SIGNATURE": "0xf74b3ca574647f8595624b129324afa2f38b598a9c1c7cfc5f08a9c036ec5acd3c0fbb9ed3dae5ca23a0a65a34b5d6cccdd6ba248985d6041f7b21262b17af6f"
 }

src/lib.rs

@@ -679,7 +679,11 @@ pub(crate) mod tests {
             arguments_file_path: P,
         ) -> TestCase<CompiledProgram> {
             let arguments_text = std::fs::read_to_string(arguments_file_path).unwrap();
-            let arguments = match serde_json::from_str::<Arguments>(&arguments_text) {
+            let unresolved = match serde_json::from_str::<UnresolvedValues>(&arguments_text) {
+                Ok(x) => x,
+                Err(error) => panic!("{error}"),
+            };
+            let arguments = match unresolved.resolve(self.program.parameters()) {
                 Ok(x) => x,
                 Err(error) => panic!("{error}"),
             };
@@ -741,7 +745,11 @@ pub(crate) mod tests {
             witness_file_path: P,
         ) -> TestCase<SatisfiedProgram> {
             let witness_text = std::fs::read_to_string(witness_file_path).unwrap();
-            let witness_values = match serde_json::from_str::<WitnessValues>(&witness_text) {
+            let unresolved = match serde_json::from_str::<UnresolvedValues>(&witness_text) {
+                Ok(x) => x,
+                Err(error) => panic!("{error}"),
+            };
+            let witness_values = match unresolved.resolve(self.program.witness_types()) {
                 Ok(x) => x,
                 Err(error) => panic!("{error}"),
             };

src/main.rs

@@ -6,7 +6,7 @@ use simplicityhl::ast::ElementsJetHinter;
 use simplicityhl::version::SimcDirective;
 use simplicityhl::{
     resolution::DependencyMapBuilder, source::CanonPath, source::CanonSourceFile, AbiMeta,
-    CompiledProgram,
+    TemplateProgram,
 };
 use simplicityhl::{UnstableFeature, UnstableFeatures};
 use std::path::Path;
@@ -132,24 +132,25 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             UnstableFeatures::new(features.copied())
         });
 
+    // Argument values are resolved against the program's parameter types,
+    // so the file is parsed here and resolved once the template is built.
     #[cfg(feature = "serde")]
-    let args_opt: simplicityhl::Arguments = match matches.get_one::<String>("args_file") {
-        None => simplicityhl::Arguments::default(),
-        Some(args_file) => {
-            let args_path = Path::new(&args_file);
-            let args_text = std::fs::read_to_string(args_path).map_err(|e| e.to_string())?;
-            serde_json::from_str::<simplicityhl::Arguments>(&args_text)?
-        }
-    };
+    let unresolved_args: Option<simplicityhl::UnresolvedValues> =
+        match matches.get_one::<String>("args_file") {
+            None => None,
+            Some(args_file) => {
+                let args_path = Path::new(&args_file);
+                let args_text = std::fs::read_to_string(args_path).map_err(|e| e.to_string())?;
+                Some(serde_json::from_str(&args_text)?)
+            }
+        };
     #[cfg(not(feature = "serde"))]
-    let args_opt: simplicityhl::Arguments = if matches.contains_id("args_file") {
+    if matches.contains_id("args_file") {
         return Err(
             "Program was compiled without the 'serde' feature and cannot process .args files."
                 .into(),
         );
-    } else {
-        simplicityhl::Arguments::default()
-    };
+    }
 
     let dep_args = matches
         .get_many::<String>("dependencies")
@@ -195,14 +196,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     let source = CanonSourceFile::new(main_path.clone(), std::sync::Arc::from(main_text));
-    let compiled = match CompiledProgram::new_with_dep(
+    let template = match TemplateProgram::new_with_dep(
         source,
         &dependencies,
         &unstable_features,
-        args_opt,
-        include_debug_symbols,
         Box::new(ElementsJetHinter::new()),
     ) {
+        Ok(program) => program,
+        Err(e) => {
+            // `Display` is message-only; render for source snippets with
+            // file and line pointers, as the single-file path does.
+            eprintln!("{}", e.render_to_string());
+            std::process::exit(1);
+        }
+    };
+
+    #[cfg(feature = "serde")]
+    let args_opt: simplicityhl::Arguments = match unresolved_args {
+        None => simplicityhl::Arguments::default(),
+        Some(unresolved) => unresolved.resolve(template.parameters())?,
+    };
+    #[cfg(not(feature = "serde"))]
+    let args_opt = simplicityhl::Arguments::default();
+
+    let compiled = match template.instantiate(args_opt, include_debug_symbols) {
         Ok(program) => program,
         Err(e) => {
             eprintln!("{}", e);
@@ -216,8 +233,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map(|wit_file| -> Result<simplicityhl::WitnessValues, String> {
             let wit_path = Path::new(wit_file);
             let wit_text = std::fs::read_to_string(wit_path).map_err(|e| e.to_string())?;
-            let witness = serde_json::from_str::<simplicityhl::WitnessValues>(&wit_text).unwrap();
-            Ok(witness)
+            let unresolved = serde_json::from_str::<simplicityhl::UnresolvedValues>(&wit_text)
+                .map_err(|e| e.to_string())?;
+            unresolved.resolve(compiled.witness_types())
         })
         .transpose()?;
     #[cfg(not(feature = "serde"))]