Merge BlockstreamResearch#63: Add new witness parser

36800e2 test: Witness error paths (Christian Lewe)
b67a8d1 refactor: Remove unnecessary map_err (Christian Lewe)
2e1b7ac rename: ReusedWitness -> WitnessReused (Christian Lewe)
fc507fa feat: Add constructors to TypedValue (Christian Lewe)
52cbd3a test: Use witness data in example programs (Christian Lewe)
001e902 feat: Restore support for witness files (Christian Lewe)
f70e8d0 feat: Convert ConstructNode to WitnessNode (Christian Lewe)
b2e51f2 feat: Add ConstructNode (Christian Lewe)
8523e24 feat: Parse WitnessValues from JSON (Christian Lewe)
fa4c92f feat: Compute typed value from const expression (Christian Lewe)
b6e08e0 feat: Add witness values (Christian Lewe)
031beb0 feat: Create spans from strings (Christian Lewe)
e470543 refactor: Error (Christian Lewe)
52d75cc refactor: RichError::Display (Christian Lewe)
78d3510 feat: Parse values from strings (Christian Lewe)

Pull request description:

  Add a parser for the new witness JSON format:

  ```json
  {
    "name": {
      "value": "42",
      "type": "u8"
    }
  }
  ```

  First we use serde_json to parse the JSON file. Then, we parse the `type` field as a `ResolvedType`. Finally, we parse the `value` field as a const expression that can be evaluated at compile time to a value, namely the witness value. Const expressions enable us to write witness files in the same way we write Simfony programs.

  Replace the reimplementation of `NamedConstructNode` with a simpler reimplementation of `ConstructNode` where witness nodes contain their name. Other nodes don't need to be named. This change is messy in terms of lines of code, but it should be quite mechanical.

  Implement a conversion from `NamedConstructNode` to `WitnessNode`, which enables pruning. I haven't tested how well rust-simplicity prunes compiled Simfony programs. We might need to push a followup PR to fix issues if we find them, but there is little we can do on the Simfony side, in my estimation.

  We could do with more unit tests, but I felt like pushing this now.

ACKs for top commit:
  apoelstra:
    ACK 36800e2

Tree-SHA512: ffe2b778d7c9c75dd547bd6b5038d424dd932f0ce1870be25065ab316cb5147df33582090410922d96eda100a5bc13cd9f294128c16a43b35d587fb5005a2639

Author: uncomputable

example_progs/checksigfromstackverify.simf

@@ -6,6 +6,6 @@
 
 // In the future, we could use jets to compute a custom sighash
 let pk: u256 = 0xf9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9;
-let msg: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
-let sig: [u8; 64] = [0xe9, 0x07, 0x83, 0x1f, 0x80, 0x84, 0x8d, 0x10, 0x69, 0xa5, 0x37, 0x1b, 0x40, 0x24, 0x10, 0x36, 0x4b, 0xdf, 0x1c, 0x5f, 0x83, 0x07, 0xb0, 0x08, 0x4c, 0x55, 0xf1, 0xce, 0x2d, 0xca, 0x82, 0x15, 0x25, 0xf6, 0x6a, 0x4a, 0x85, 0xea, 0x8b, 0x71, 0xe4, 0x82, 0xa7, 0x4f, 0x38, 0x2d, 0x2c, 0xe5, 0xeb, 0xee, 0xe8, 0xfd, 0xb2, 0x17, 0x2f, 0x47, 0x7d, 0xf4, 0x90, 0x0d, 0x31, 0x05, 0x36, 0xc0];
+let msg: u256 = witness("msg");
+let sig: [u8; 64] = witness("sig");
 jet_bip_0340_verify(pk, msg, sig);

example_progs/checksigfromstackverify.wit

@@ -0,0 +1,10 @@
+{
+    "msg": {
+        "value": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "type": "u256"
+    },
+    "sig": {
+        "value": "[0xe9, 0x07, 0x83, 0x1f, 0x80, 0x84, 0x8d, 0x10, 0x69, 0xa5, 0x37, 0x1b, 0x40, 0x24, 0x10, 0x36, 0x4b, 0xdf, 0x1c, 0x5f, 0x83, 0x07, 0xb0, 0x08, 0x4c, 0x55, 0xf1, 0xce, 0x2d, 0xca, 0x82, 0x15, 0x25, 0xf6, 0x6a, 0x4a, 0x85, 0xea, 0x8b, 0x71, 0xe4, 0x82, 0xa7, 0x4f, 0x38, 0x2d, 0x2c, 0xe5, 0xeb, 0xee, 0xe8, 0xfd, 0xb2, 0x17, 0x2f, 0x47, 0x7d, 0xf4, 0x90, 0x0d, 0x31, 0x05, 0x36, 0xc0]",
+        "type": "[u8; 64]"
+    }
+}

example_progs/empty.wit

@@ -1,3 +1 @@
-{
-	
-}
+{}

example_progs/sighash_all_anyprevoutanyscript.simf

@@ -23,5 +23,5 @@ let ctx: Ctx8 = jet_sha_256_ctx_8_add_32(ctx, jet_output_surjection_proofs_hash(
 let msg: u256 = jet_sha_256_ctx_8_finalize(ctx);
 
 let pk: u256 = 0xf9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9;
-let sig: [u8; 64] = [0xc9, 0x39, 0xe3, 0x23, 0x44, 0x64, 0x2e, 0x3c, 0x22, 0x8b, 0x01, 0x62, 0x04, 0x18, 0x24, 0xaf, 0xe1, 0x94, 0x29, 0x74, 0x77, 0x18, 0x82, 0x55, 0xd2, 0x63, 0x79, 0x08, 0xa0, 0xd0, 0x0d, 0x1f, 0xdf, 0x59, 0x21, 0x4a, 0x30, 0x4d, 0xdf, 0x18, 0x0b, 0x1a, 0x07, 0x01, 0x9a, 0x60, 0xd8, 0x08, 0xd1, 0x81, 0x70, 0xfb, 0x77, 0xfd, 0x3b, 0x00, 0xec, 0xa7, 0x66, 0x67, 0xd7, 0xaa, 0x26, 0x8e];
+let sig: [u8; 64] = witness("sig");
 jet_bip_0340_verify(pk, msg, sig);

example_progs/sighash_all_anyprevoutanyscript.wit

@@ -0,0 +1,6 @@
+{
+    "sig": {
+        "value": "[0xc9, 0x39, 0xe3, 0x23, 0x44, 0x64, 0x2e, 0x3c, 0x22, 0x8b, 0x01, 0x62, 0x04, 0x18, 0x24, 0xaf, 0xe1, 0x94, 0x29, 0x74, 0x77, 0x18, 0x82, 0x55, 0xd2, 0x63, 0x79, 0x08, 0xa0, 0xd0, 0x0d, 0x1f, 0xdf, 0x59, 0x21, 0x4a, 0x30, 0x4d, 0xdf, 0x18, 0x0b, 0x1a, 0x07, 0x01, 0x9a, 0x60, 0xd8, 0x08, 0xd1, 0x81, 0x70, 0xfb, 0x77, 0xfd, 0x3b, 0x00, 0xec, 0xa7, 0x66, 0x67, 0xd7, 0xaa, 0x26, 0x8e]",
+        "type": "[u8; 64]"
+    }
+}

example_progs/sighash_none.simf

@@ -21,5 +21,5 @@ let ctx: Ctx8 = jet_sha_256_ctx_8_add_4(ctx, jet_current_index());
 let msg: u256 = jet_sha_256_ctx_8_finalize(ctx);
 
 let pk: u256 = 0xf9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9;
-let sig: [u8; 64] = [0x34, 0x61, 0x52, 0x58, 0x3d, 0x5b, 0x60, 0xb9, 0x72, 0xbb, 0x4c, 0x03, 0xab, 0x67, 0x2e, 0x33, 0x94, 0x31, 0x06, 0x0e, 0x2b, 0x09, 0xc4, 0x47, 0xab, 0x98, 0x3c, 0x65, 0xda, 0xbc, 0x70, 0xa4, 0x59, 0xf3, 0xbe, 0xca, 0x77, 0x88, 0xbf, 0xa5, 0xda, 0x22, 0x1c, 0xf9, 0x92, 0x27, 0xb6, 0x5b, 0x4a, 0xd3, 0x82, 0x1a, 0x20, 0x45, 0xc8, 0x47, 0xee, 0x56, 0xd4, 0x8d, 0xf2, 0x6a, 0xee, 0x9c];
+let sig: [u8; 64] = witness("sig");
 jet_bip_0340_verify(pk, msg, sig);

example_progs/sighash_none.wit

@@ -0,0 +1,6 @@
+{
+    "sig": {
+        "value": "[0x34, 0x61, 0x52, 0x58, 0x3d, 0x5b, 0x60, 0xb9, 0x72, 0xbb, 0x4c, 0x03, 0xab, 0x67, 0x2e, 0x33, 0x94, 0x31, 0x06, 0x0e, 0x2b, 0x09, 0xc4, 0x47, 0xab, 0x98, 0x3c, 0x65, 0xda, 0xbc, 0x70, 0xa4, 0x59, 0xf3, 0xbe, 0xca, 0x77, 0x88, 0xbf, 0xa5, 0xda, 0x22, 0x1c, 0xf9, 0x92, 0x27, 0xb6, 0x5b, 0x4a, 0xd3, 0x82, 0x1a, 0x20, 0x45, 0xc8, 0x47, 0xee, 0x56, 0xd4, 0x8d, 0xf2, 0x6a, 0xee, 0x9c]",
+        "type": "[u8; 64]"
+    }
+}

src/ast.rs

@@ -349,7 +349,7 @@ impl Scope {
     /// Witness names may be used at most throughout the entire program.
     pub fn insert_witness(&mut self, name: WitnessName, ty: ResolvedType) -> Result<(), Error> {
         match self.witnesses.entry(name.clone()) {
-            Entry::Occupied(_) => Err(Error::ReusedWitness(name)),
+            Entry::Occupied(_) => Err(Error::WitnessReused(name)),
             Entry::Vacant(entry) => {
                 entry.insert(ty);
                 Ok(())
@@ -522,7 +522,6 @@ impl AbstractSyntaxTree for SingleExpression {
             parse::SingleExpressionInner::Witness(name) => {
                 scope
                     .insert_witness(name.clone(), ty.clone())
-                    .map_err(|_| Error::ReusedWitness(name.clone()))
                     .with_span(from)?;
                 SingleExpressionInner::Witness(name.clone())
             }

src/compile.rs

@@ -1,7 +1,7 @@
 //! Compile the parsed ast into a simplicity program
 
 use either::Either;
-use simplicity::node::{CoreConstructible as _, JetConstructible as _};
+use simplicity::node::{CoreConstructible as _, JetConstructible as _, WitnessConstructible as _};
 use simplicity::{Cmr, FailEntropy};
 
 use crate::array::{BTreeSlice, Partition};
@@ -10,7 +10,7 @@ use crate::ast::{
     SingleExpressionInner, Statement,
 };
 use crate::error::{Error, RichError, WithSpan};
-use crate::named::{ConstructExt, ProgExt};
+use crate::named::CoreExt;
 use crate::pattern::{BasePattern, Pattern};
 use crate::types::{StructuralType, TypeDeconstructible};
 use crate::value::StructuralValue;
@@ -208,7 +208,7 @@ impl SingleExpression {
                 let value = StructuralValue::from(value);
                 ProgNode::unit_comp(&ProgNode::const_word(value.into()))
             }
-            SingleExpressionInner::Witness(name) => ProgNode::witness(name.as_inner().clone()),
+            SingleExpressionInner::Witness(name) => ProgNode::witness(name.clone()),
             SingleExpressionInner::Variable(identifier) => scope
                 .get(&BasePattern::Identifier(identifier.clone()))
                 .ok_or(Error::UndefinedVariable(identifier.clone()))
@@ -247,7 +247,7 @@ impl SingleExpression {
                             })
                         })
                         .map(|res| res.map(|array| ProgNode::injr(&array)))
-                        .unwrap_or_else(|| Ok(ProgNode::_false()))
+                        .unwrap_or_else(|| Ok(ProgNode::bit_false()))
                     };
 
                 partition.fold(process, |res_a, res_b| {
@@ -268,7 +268,8 @@ impl SingleExpression {
             SingleExpressionInner::Match(match_) => match_.compile(scope)?,
         };
 
-        expr.arrow()
+        expr.cached_data()
+            .arrow()
             .target
             .unify(&StructuralType::from(self.ty()).to_unfinalized(), "")
             .map_err(|e| Error::CannotCompile(e.to_string()))

src/error.rs

@@ -18,7 +18,7 @@ impl<T, E: Into<Error>> WithSpan<T> for Result<T, E> {
     }
 }
 
-/// Helper trait to update `Result<A, RichError>` with the the affected source file.
+/// Helper trait to update `Result<A, RichError>` with the affected source file.
 pub trait WithFile<T> {
     /// Update the result with the affected source file.
     ///
@@ -71,42 +71,48 @@ impl RichError {
 
 impl fmt::Display for RichError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let start_line_index = self.span.start.line.get() - 1;
-        let end_line_index = self.span.end.line.get() - 1;
-        let line_num_width = self.span.end.line.get().to_string().len();
-        writeln!(f, "{:width$} |", " ", width = line_num_width)?;
-
-        if let Some(ref file) = self.file {
-            let mut lines = file.lines().skip(start_line_index).peekable();
-            let start_line_len = lines.peek().map(|l| l.len()).unwrap_or(0);
-            for (relative_line_index, line_str) in lines
-                .take(end_line_index - start_line_index + 1)
-                .enumerate()
-            {
-                let line_num = start_line_index + relative_line_index + 1;
-                writeln!(f, "{line_num:line_num_width$} | {line_str}")?;
+        match self.file {
+            Some(ref file) if !file.is_empty() => {
+                let start_line_index = self.span.start.line.get() - 1;
+                let n_spanned_lines = self.span.end.line.get() - start_line_index;
+                let line_num_width = self.span.end.line.get().to_string().len();
+                writeln!(f, "{:width$} |", " ", width = line_num_width)?;
+
+                let mut lines = file.lines().skip(start_line_index).peekable();
+                let start_line_len = lines.peek().map(|l| l.len()).unwrap_or(0);
+
+                for (relative_line_index, line_str) in lines.take(n_spanned_lines).enumerate() {
+                    let line_num = start_line_index + relative_line_index + 1;
+                    writeln!(f, "{line_num:line_num_width$} | {line_str}")?;
+                }
+
+                let (underline_start, underline_length) = match self.span.is_multiline() {
+                    true => (0, start_line_len),
+                    false => (
+                        self.span.start.col.get(),
+                        self.span.end.col.get() - self.span.start.col.get(),
+                    ),
+                };
+                write!(f, "{:width$} |", " ", width = line_num_width)?;
+                write!(f, "{:width$}", " ", width = underline_start)?;
+                write!(f, "{:^<width$} ", "", width = underline_length)?;
+                write!(f, "{}", self.error)
+            }
+            _ => {
+                write!(f, "{}", self.error)
             }
-            let (underline_start, underline_length) = if self.span.is_multiline() {
-                (0, start_line_len)
-            } else {
-                (
-                    self.span.start.col.get(),
-                    self.span.end.col.get() - self.span.start.col.get(),
-                )
-            };
-            write!(f, "{:width$} |", " ", width = line_num_width)?;
-            write!(f, "{:width$}", " ", width = underline_start)?;
-            write!(f, "{:^<width$} ", "", width = underline_length)?;
-            write!(f, "{}", self.error)
-        } else {
-            let start_line_num = self.span.end.line.get();
-            write!(f, "{start_line_num} | {}", self.error)
         }
     }
 }
 
 impl std::error::Error for RichError {}
 
+impl From<RichError> for Error {
+    fn from(error: RichError) -> Self {
+        error.error
+    }
+}
+
 impl From<RichError> for String {
     fn from(error: RichError) -> Self {
         error.to_string()
@@ -148,11 +154,14 @@ pub enum Error {
     TypeValueMismatch(ResolvedType),
     InvalidNumberOfArguments(usize, usize),
     ExpressionTypeMismatch(ResolvedType, ResolvedType),
+    ExpressionNotConstant,
     IntegerOutOfBounds(UIntType),
     UndefinedVariable(Identifier),
     UndefinedAlias(Identifier),
     VariableReuseInPattern(Identifier),
-    ReusedWitness(WitnessName),
+    WitnessReused(WitnessName),
+    WitnessTypeMismatch(WitnessName, ResolvedType, ResolvedType),
+    WitnessReassigned(WitnessName),
 }
 
 #[rustfmt::skip]
@@ -203,6 +212,10 @@ impl fmt::Display for Error {
                 f,
                 "Expected expression of type `{expected}`, found type `{found}`"
             ),
+            Error::ExpressionNotConstant => write!(
+                f,
+                "Expression cannot be evaluated at compile time"
+            ),
             Error::IntegerOutOfBounds(ty) => write!(
                 f,
                 "Value is out of bounds for type `{ty}`"
@@ -219,10 +232,18 @@ impl fmt::Display for Error {
                 f,
                 "Variable `{identifier}` is used twice in the pattern"
             ),
-            Error::ReusedWitness(name) => write!(
+            Error::WitnessReused(name) => write!(
                 f,
                 "Witness `{name}` has been used before somewhere in the program"
             ),
+            Error::WitnessTypeMismatch(name, declared, assigned) => write!(
+                f,
+                "Witness `{name}` was declared with type `{declared}` but its assigned value is of type `{assigned}`"
+            ),
+            Error::WitnessReassigned(name) => write!(
+                f,
+                "Witness `{name}` has already been assigned a value"
+            )
         }
     }
 }
@@ -231,8 +252,8 @@ impl std::error::Error for Error {}
 
 impl Error {
     /// Update the error with the affected span.
-    pub fn with_span<S: Into<Span>>(self, span: S) -> RichError {
-        RichError::new(self, span.into())
+    pub fn with_span(self, span: Span) -> RichError {
+        RichError::new(self, span)
     }
 }
 
@@ -267,8 +288,8 @@ mod tests {
     const FILE: &str = r#"let a1: List<u32, 5> = None;
 let x: u32 = Left(
     Right(0)
-);
-"#;
+);"#;
+    const EMPTY_FILE: &str = "";
 
     #[test]
     fn display_single_line() {
@@ -297,4 +318,45 @@ let x: u32 = Left(
   | ^^^^^^^^^^^^^^^^^^ Cannot parse: Expected value of type `u32`, got `Either<Either<_, u32>, _>`"#;
         assert_eq!(&expected[1..], &error.to_string());
     }
+
+    #[test]
+    fn display_entire_file() {
+        let error = Error::CannotParse("This span covers the entire file".to_string())
+            .with_span(Span::from(FILE))
+            .with_file(Arc::from(FILE));
+        let expected = r#"
+  |
+1 | let a1: List<u32, 5> = None;
+2 | let x: u32 = Left(
+3 |     Right(0)
+4 | );
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Cannot parse: This span covers the entire file"#;
+        assert_eq!(&expected[1..], &error.to_string());
+    }
+
+    #[test]
+    fn display_no_file() {
+        let error = Error::CannotParse("This error has no file".to_string())
+            .with_span(Span::from(EMPTY_FILE));
+        let expected = "Cannot parse: This error has no file";
+        assert_eq!(&expected, &error.to_string());
+
+        let error = Error::CannotParse("This error has no file".to_string())
+            .with_span(Span::new(Position::new(1, 1), Position::new(2, 2)));
+        assert_eq!(&expected, &error.to_string());
+    }
+
+    #[test]
+    fn display_empty_file() {
+        let error = Error::CannotParse("This error has an empty file".to_string())
+            .with_span(Span::from(EMPTY_FILE))
+            .with_file(Arc::from(EMPTY_FILE));
+        let expected = "Cannot parse: This error has an empty file";
+        assert_eq!(&expected, &error.to_string());
+
+        let error = Error::CannotParse("This error has an empty file".to_string())
+            .with_span(Span::new(Position::new(1, 1), Position::new(2, 2)))
+            .with_file(Arc::from(EMPTY_FILE));
+        assert_eq!(&expected, &error.to_string());
+    }
 }