Merge BlockstreamResearch#59: Remove old witness parser

4ee3499 Lib: Take program text as input (Christian Lewe)
45207d9 Combine _compile and compile (Christian Lewe)
921d38a Fix: Remove unnecessary comments (Christian Lewe)
3a34bff Remove old witness file parsing (Christian Lewe)
6fb1732 Fix: Broken doc links (Christian Lewe)
0ec0422 Move IdentParser into parse module (Christian Lewe)
4d7f93d Remove `test` example program (Christian Lewe)
621cfe7 Remove old unit test (Christian Lewe)

Pull request description:

  Remove the old witness file parser which used the Simplicity bit encoding and which was prone to fail. Temporarily disable witness expressions (during satisfaction) because we don't have the new witness file parser yet. Present error messages to prevent confusion. Refactor the library functions `compile` and `satisfy` so they are usable by the web IDE, which handles strings instead of files on disk.

ACKs for top commit:
  apoelstra:
    ACK 4ee3499

Tree-SHA512: 5d9a969e42d7e68261f5a2bff720251cde11d96f4db331bd433ea2df8e3e106786d3dd48cd351f840805c1872434bac5d25ed8f168e87682bb0a73ff53abb84a

Author: uncomputable

example_progs/test.simf

@@ -3,9 +3,8 @@ use std::sync::Arc;
 
 use simplicity::elements;
 
-use crate::parse::{Identifier, JetName, MatchPattern, Position, Span, WitnessName};
+use crate::parse::{Identifier, JetName, MatchPattern, Position, Rule, Span, WitnessName};
 use crate::types::{ResolvedType, UIntType};
-use crate::Rule;
 
 /// Helper trait to convert `Result<T, E>` into `Result<T, RichError>`.
 pub trait WithSpan<T> {

example_progs/test.wit

@@ -15,144 +15,43 @@ pub mod pattern;
 pub mod types;
 pub mod value;
 
-use std::{collections::HashMap, path::Path, sync::Arc};
+use std::sync::Arc;
 
-use named::{ConstructExt, Named};
-use pest::Parser;
-use pest_derive::Parser;
-use simplicity::{
-    dag::{NoSharing, PostOrderIterItem},
-    jet::Elements,
-    node::{Commit, Converter, Inner, Node, Redeem, RedeemData},
-    BitIter, CommitNode, RedeemNode,
-};
+use named::ConstructExt;
+use simplicity::{dag::NoSharing, jet::Elements, node::Redeem, CommitNode, RedeemNode};
 
 pub extern crate simplicity;
 pub use simplicity::elements;
+use simplicity::node::SimpleFinalizer;
 
-use crate::{
-    error::{RichError, WithFile},
-    named::{NamedCommitNode, NamedExt},
-    parse::PestParse,
-};
+use crate::{error::WithFile, named::NamedExt};
 
-#[derive(Parser)]
-#[grammar = "minimal.pest"]
-pub struct IdentParser;
-
-pub fn _compile(file: &Path) -> Result<Arc<Node<Named<Commit<Elements>>>>, String> {
-    let file = Arc::from(std::fs::read_to_string(file).unwrap());
-    let parse_program = IdentParser::parse(Rule::program, &file)
-        .map_err(RichError::from)
-        .and_then(|mut pairs| parse::Program::parse(pairs.next().unwrap()))
-        .with_file(file.clone())?;
-    let ast_program = ast::Program::analyze(&parse_program).with_file(file.clone())?;
-    let simplicity_named_commit = ast_program.compile().with_file(file.clone())?;
-    let simplicity_redeem = simplicity_named_commit
+pub fn compile(prog_text: &str) -> Result<Arc<CommitNode<Elements>>, String> {
+    let parse_program = parse::Program::parse(prog_text)?;
+    let ast_program = ast::Program::analyze(&parse_program).with_file(prog_text)?;
+    let simplicity_named_construct = ast_program.compile().with_file(prog_text)?;
+    let simplicity_named_commit = simplicity_named_construct
         .finalize_types_main()
-        .expect("Type check error");
-    Ok(simplicity_redeem)
-}
-
-pub fn compile(file: &Path) -> Result<CommitNode<Elements>, String> {
-    let simplicity_named_commit = _compile(file)?;
-    Ok(Arc::try_unwrap(simplicity_named_commit.to_commit_node()).unwrap())
+        .expect("Failed to set program source and target type to unit");
+    Ok(simplicity_named_commit.to_commit_node())
 }
 
-pub fn satisfy(prog: &Path, wit_file: &Path) -> Result<RedeemNode<Elements>, String> {
-    #[derive(serde::Serialize, serde::Deserialize)]
-    #[serde(transparent)]
-    struct WitFileData {
-        map: HashMap<String, String>,
-    }
-
-    impl Converter<Named<Commit<Elements>>, Redeem<Elements>> for WitFileData {
-        type Error = std::convert::Infallible;
-
-        fn convert_witness(
-            &mut self,
-            data: &PostOrderIterItem<&NamedCommitNode>,
-            _witness: &<Named<Commit<Elements>> as simplicity::node::Marker>::Witness,
-        ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::Witness, Self::Error> {
-            let key = data.node.name();
-            let ty = &data.node.arrow().target;
-            match self.map.get(key.as_ref()) {
-                Some(wit) => {
-                    let bytes: Vec<u8> = hex_conservative::FromHex::from_hex(wit).unwrap();
-                    let total_bit_len = bytes.len() * 8;
-                    let mut bit_iter = BitIter::new(bytes.into_iter());
-                    let value = bit_iter.read_value(&data.node.arrow().target);
-                    let v = match value {
-                        Ok(v) => v,
-                        Err(e) => panic!("Error reading witness: {:?}", e),
-                    };
-                    // TODO: Make sure that remaining iterator is empty or all zeros till the specified remaining len.
-                    let bit_len = ty.bit_width();
-                    let remaining = total_bit_len - bit_len;
-                    assert!(remaining < 8);
-                    for _ in 0..remaining {
-                        assert!(!bit_iter.next().unwrap());
-                    }
-                    assert!(bit_iter.next().is_none());
-                    Ok(v)
-                }
-                None => panic!("Value not found{}", key),
-            }
-        }
-
-        fn convert_disconnect(
-            &mut self,
-            _data: &PostOrderIterItem<&NamedCommitNode>,
-            _maybe_converted: Option<&Arc<simplicity::node::Node<Redeem<Elements>>>>,
-            _disconnect: &<Named<Commit<Elements>> as simplicity::node::Marker>::Disconnect,
-        ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::Disconnect, Self::Error>
-        {
-            todo!()
-        }
-
-        fn convert_data(
-            &mut self,
-            data: &PostOrderIterItem<&NamedCommitNode>,
-            inner: Inner<
-                &Arc<simplicity::node::Node<Redeem<Elements>>>,
-                <Redeem<Elements> as simplicity::node::Marker>::Jet,
-                &<Redeem<Elements> as simplicity::node::Marker>::Disconnect,
-                &<Redeem<Elements> as simplicity::node::Marker>::Witness,
-            >,
-        ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::CachedData, Self::Error>
-        {
-            let converted_data = inner
-                .map(|node| node.cached_data())
-                .map_disconnect(|node| node.cached_data())
-                .map_witness(Arc::clone);
-            Ok(Arc::new(RedeemData::new(
-                data.node.arrow().shallow_clone(),
-                converted_data,
-            )))
-        }
-    }
-
-    let simplicity_named_commit = _compile(prog)?;
-    let simplicity_named_commit =
-        Arc::<_>::try_unwrap(simplicity_named_commit).expect("Only one reference to commit node");
-
-    let file = std::fs::File::open(wit_file).expect("Error opening witness file");
-    let rdr = std::io::BufReader::new(file);
-    let mut wit_data: WitFileData =
-        serde_json::from_reader(rdr).expect("Error reading witness file");
-
-    let simplicity_redeem = simplicity_named_commit
-        .convert::<NoSharing, Redeem<Elements>, _>(&mut wit_data)
-        .unwrap();
-    Ok(Arc::try_unwrap(simplicity_redeem).unwrap())
+pub fn satisfy(prog_text: &str) -> Result<Arc<RedeemNode<Elements>>, String> {
+    let simplicity_named_commit = compile(prog_text)?;
+    let mut finalizer = SimpleFinalizer::new(std::iter::empty());
+    simplicity_named_commit
+        .convert::<NoSharing, Redeem<Elements>, _>(&mut finalizer)
+        .map_err(|_| {
+            "Witness expressions are temporarily not supported. Cannot satisfy.".to_string()
+        })
 }
 
 #[cfg(test)]
 mod tests {
     use base64::display::Base64Display;
     use base64::engine::general_purpose::STANDARD;
-    use simplicity::node::{CoreConstructible as _, JetConstructible as _};
-    use simplicity::{encode, BitMachine, BitWriter, Cmr, Value};
+    use simplicity::{encode, BitMachine, BitWriter};
+    use std::path::Path;
 
     use crate::*;
 
@@ -171,71 +70,21 @@ mod tests {
         _test_progs("./example_progs/sighash_all.simf");
         _test_progs("./example_progs/sighash_all_anyprevoutanyscript.simf");
         _test_progs("./example_progs/sighash_none.simf");
-        _test_progs("./example_progs/test.simf");
         _test_progs("./example_progs/tuple.simf");
         _test_progs("./example_progs/unwrap.simf");
     }
 
     fn _test_progs(file: &str) {
         println!("Testing {file}");
-        let file = Path::new(file);
-        let simplicity_named_commit = match _compile(file) {
+        let path = Path::new(file);
+        let text = std::fs::read_to_string(path).unwrap();
+        let redeem_prog = match satisfy(&text) {
             Ok(commit) => commit,
             Err(error) => {
                 panic!("{error}");
             }
         };
 
-        struct MyConverter;
-
-        impl Converter<Named<Commit<Elements>>, Redeem<Elements>> for MyConverter {
-            type Error = std::convert::Infallible;
-
-            fn convert_witness(
-                &mut self,
-                _data: &PostOrderIterItem<&NamedCommitNode>,
-                _witness: &<Named<Commit<Elements>> as simplicity::node::Marker>::Witness,
-            ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::Witness, Self::Error>
-            {
-                Ok(Value::u32(20))
-            }
-
-            fn convert_disconnect(
-                &mut self,
-                _data: &PostOrderIterItem<&NamedCommitNode>,
-                _maybe_converted: Option<&Arc<simplicity::node::Node<Redeem<Elements>>>>,
-                _disconnect: &<Named<Commit<Elements>> as simplicity::node::Marker>::Disconnect,
-            ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::Disconnect, Self::Error>
-            {
-                todo!()
-            }
-
-            fn convert_data(
-                &mut self,
-                data: &PostOrderIterItem<&NamedCommitNode>,
-                inner: Inner<
-                    &Arc<simplicity::node::Node<Redeem<Elements>>>,
-                    <Redeem<Elements> as simplicity::node::Marker>::Jet,
-                    &<Redeem<Elements> as simplicity::node::Marker>::Disconnect,
-                    &<Redeem<Elements> as simplicity::node::Marker>::Witness,
-                >,
-            ) -> Result<<Redeem<Elements> as simplicity::node::Marker>::CachedData, Self::Error>
-            {
-                let converted_data = inner
-                    .map(|node| node.cached_data())
-                    .map_disconnect(|node| node.cached_data())
-                    .map_witness(Arc::clone);
-                Ok(Arc::new(RedeemData::new(
-                    data.node.arrow().shallow_clone(),
-                    converted_data,
-                )))
-            }
-        }
-
-        let redeem_prog = simplicity_named_commit
-            .convert::<NoSharing, Redeem<Elements>, _>(&mut MyConverter)
-            .unwrap();
-
         let mut vec = Vec::new();
         let mut writer = BitWriter::new(&mut vec);
         let _encoded = encode::encode_program(&redeem_prog, &mut writer).unwrap();
@@ -248,27 +97,4 @@ mod tests {
             .exec(&redeem_prog, &env)
             .expect("Machine execution failure");
     }
-
-    #[test]
-    fn temp_progs() {
-        let inp = ProgNode::const_word(Value::u32(10));
-        let node = ProgNode::jet(Elements::ParseLock);
-        println!("l1: {}", node.arrow());
-        let node = ProgNode::comp(&inp, &node).unwrap();
-        println!("l2: {}", node.arrow());
-        let node = ProgNode::pair(&node, &ProgNode::unit()).unwrap();
-        println!("l3: {}", node.arrow());
-        let later_operation = ProgNode::take(&ProgNode::unit());
-        println!("l4: {}", later_operation.arrow());
-        let assert_node = ProgNode::assertl(&later_operation, Cmr::unit()).unwrap();
-        println!("l5: {}", assert_node.arrow());
-        let comp = ProgNode::comp(&node, &assert_node).unwrap();
-        println!("l6: {}", comp.arrow());
-        // let node2 = ProgNode::assert(&node, Cmr::unit()).unwrap();
-        // println!("l3: {}", node2.arrow());
-        // let node3 = ProgNode::comp(&ProgNode::pair(&ProgNode::unit(), &ProgNode::unit()).unwrap(), &node2).unwrap();
-        // println!("l4: {}", node3.arrow());
-        let res = comp.finalize_types_main().unwrap();
-        dbg!(&res);
-    }
 }

src/error.rs

@@ -15,31 +15,32 @@ fn main() {
 }
 
 fn run() -> Result<(), String> {
-    // Get the command-line arguments as a Vec<String>.
     let args: Vec<String> = env::args().collect();
 
-    // Check if at least two arguments are provided.
     if args.len() < 2 {
         println!("Usage: {} <prog.simpl> [sig.wit (optional)]", args[0]);
         println!("If no witness file is provided, the program will be compiled and printed.");
         println!("If a witness file is provided, the program will be satisfied and printed.");
         return Ok(());
     }
 
-    // Extract the first argument (arg1).
     let prog_file = &args[1];
     let prog_path = std::path::Path::new(prog_file);
+    let prog_text = std::fs::read_to_string(prog_path).map_err(|e| e.to_string())?;
 
-    // Check if a second argument (arg2) is provided.
     if args.len() >= 3 {
-        let witness_file = &args[2];
-        let wit_path = std::path::Path::new(witness_file);
-        let res = satisfy(prog_path, wit_path)?;
+        // TODO: Re-enable witness file parsing
+        println!(
+            "Warning: Witness expressions are temporarily disabled. Skipping the witness file..."
+        );
+        // let witness_file = &args[2];
+        // let wit_path = std::path::Path::new(witness_file);
+        let res = satisfy(&prog_text)?;
         let redeem_bytes = res.encode_to_vec();
         println!("{}", Base64Display::new(&redeem_bytes, &STANDARD));
     } else {
         // No second argument is provided. Just compile the program.
-        let prog = compile(prog_path)?;
+        let prog = compile(&prog_text)?;
         let res = prog.encode_to_vec();
         println!("{}", Base64Display::new(&res, &STANDARD));
     }

src/lib.rs

@@ -8,13 +8,18 @@ use std::sync::Arc;
 
 use either::Either;
 use miniscript::iter::{Tree, TreeLike};
+use pest::Parser;
+use pest_derive::Parser;
 use simplicity::elements::hex::FromHex;
 
-use crate::error::{Error, RichError, WithSpan};
+use crate::error::{Error, RichError, WithFile, WithSpan};
 use crate::num::NonZeroPow2Usize;
 use crate::pattern::Pattern;
 use crate::types::{AliasedType, BuiltinAlias, TypeConstructible, UIntType};
-use crate::Rule;
+
+#[derive(Parser)]
+#[grammar = "minimal.pest"]
+pub struct IdentParser;
 
 /// Position of an object inside a file.
 ///
@@ -484,22 +489,27 @@ impl fmt::Display for MatchPattern {
     }
 }
 
-pub trait PestParse: Sized {
+trait PestParse: Sized {
     fn parse(pair: pest::iterators::Pair<Rule>) -> Result<Self, RichError>;
 }
 
-impl PestParse for Program {
-    fn parse(pair: pest::iterators::Pair<Rule>) -> Result<Self, RichError> {
-        assert!(matches!(pair.as_rule(), Rule::program));
-        let mut stmts = Vec::new();
-        for inner_pair in pair.into_inner() {
-            match inner_pair.as_rule() {
-                Rule::statement => stmts.push(Statement::parse(inner_pair)?),
-                Rule::EOI => (),
-                _ => unreachable!(),
-            };
-        }
-        Ok(Program { statements: stmts })
+impl Program {
+    pub fn parse(file: &str) -> Result<Self, RichError> {
+        let mut pairs = IdentParser::parse(Rule::program, file)
+            .map_err(RichError::from)
+            .with_file(file)?;
+        let pair = pairs.next().unwrap();
+
+        debug_assert!(matches!(pair.as_rule(), Rule::program));
+        let statements = pair
+            .into_inner()
+            .filter_map(|pair| match pair.as_rule() {
+                Rule::statement => Some(Statement::parse(pair)),
+                Rule::EOI => None,
+                _ => unreachable!("Corrupt grammar"),
+            })
+            .collect::<Result<Vec<Statement>, RichError>>()?;
+        Ok(Program { statements })
     }
 }