Use simplicity-sys for running test programs

Author: m-kus

.github/workflows/test.yml

@@ -21,7 +21,10 @@ jobs:
 
   test-stable:
     name: Test - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
 
     steps:
     - name: Checkout

Cargo.lock

@@ -7,7 +7,7 @@ homepage = "https://github.com/BlockstreamResearch/simfony/"
 repository = "https://github.com/BlockstreamResearch/simfony/"
 description = "Rust-like language that compiles to Simplicity bytecode."
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.78.0"
 
 [lib]
 name = "simfony"
@@ -22,12 +22,11 @@ serde = ["dep:serde", "dep:serde_json"]
 
 [dependencies]
 base64 = "0.21.2"
-hex-conservative = "0.1.1"
 pest = "2.1.3"
 pest_derive = "2.7.1"
 serde = { version = "1.0.188", features = ["derive"], optional = true }
 serde_json = { version = "1.0.105", optional = true }
-simplicity-lang = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "ca0c0ebee295937ab021ad018acc44a5aaa12649" }
+simplicity-lang = { git = "https://github.com/BlockstreamResearch/rust-simplicity", rev = "b0f851cb33677d8be3b5a6dce66f1665d35760a8", features = ["test-utils"]}
 miniscript = "12.2.0"
 either = "1.12.0"
 itertools = "0.13.0"

Cargo.toml

@@ -20,7 +20,7 @@ Take a look at the [example programs](https://github.com/BlockstreamResearch/sim
 
 ## MSRV
 
-This crate should compile with any feature combination on **Rust 1.63.0** or higher.
+This crate should compile with any feature combination on **Rust 1.78.0** or higher.
 
 ## Simplicity's need for a high-level language
 

README.md

@@ -1 +1 @@
-msrv = "1.63.0"
+msrv = "1.78.0"

clippy.toml

@@ -2,7 +2,6 @@
 name = "codegen"
 version = "0.1.0"
 edition = "2021"
-rust-version = "1.63.0"
 description = "Generator of Rust code as interface between Simfony and Rust."
 publish = false
 

codegen/Cargo.toml

@@ -14,11 +14,8 @@
   , rust-overlay
   , ...
   }:
-  flake-utils.lib.eachSystem [
-    "x86_64-linux"
-    "aarch64-linux"
-    "x86_64-darwin"
-  ] (system:
+  flake-utils.lib.eachDefaultSystem
+  (system:
     let
       overlays = [
         (import rust-overlay)
@@ -35,23 +32,24 @@
       CC_wasm32_unknown_unknown = "${pkgs.llvmPackages_16.clang-unwrapped}/bin/clang-16";
       AR_wasm32_unknown_unknown = "${pkgs.llvmPackages_16.libllvm}/bin/llvm-ar";
       CFLAGS_wasm32_unknown_unknown = "-I ${pkgs.llvmPackages_16.libclang.lib}/lib/clang/16/include/";
+      gdbSupported = !(pkgs.stdenv.isDarwin && pkgs.stdenv.isAarch64);
       default_shell = with_elements: pkgs.mkShell {
           buildInputs = [
             defaultRust
             pkgs.just
-            pkgs.gdb
             pkgs.cargo-hack
             pkgs.mdbook
           ] ++ (
             if with_elements then [ elementsd-simplicity ] else []
+          ) ++ (
+            if gdbSupported then [ pkgs.gdb ] else []
           );
           inherit CC_wasm32_unknown_unknown;
           inherit AR_wasm32_unknown_unknown;
           inherit CFLAGS_wasm32_unknown_unknown;
           # Constants for IDE
           RUST_TOOLCHAIN = "${defaultRust}/bin";
           RUST_STDLIB = "${defaultRust}/lib/rustlib/src/rust";
-          DEBUGGER = "${pkgs.gdb}";
       };
     in
     {
@@ -68,7 +66,7 @@
         };
         msrv = pkgs.mkShell {
           buildInputs = [
-            (mkRust "stable" "1.63.0" "minimal" [] [])
+            (mkRust "stable" "1.78.0" "minimal" [] [])
             pkgs.just
           ];
         };

flake.nix

@@ -249,9 +249,8 @@ pub trait ArbitraryOfType: Sized {
 mod tests {
     use base64::display::Base64Display;
     use base64::engine::general_purpose::STANDARD;
-    #[cfg(feature = "serde")]
-    use elements::LockTime;
-    use simplicity::BitMachine;
+    use simplicity::ffi::tests::ffi::SimplicityErr;
+    use simplicity::ffi::tests::{run_program, TestUpTo};
     use std::borrow::Cow;
     use std::path::Path;
 
@@ -391,10 +390,10 @@ mod tests {
             self
         }
 
-        fn run(self) -> Result<(), simplicity::bit_machine::ExecutionError> {
-            let mut mac = BitMachine::for_program(self.program.redeem());
-            let env = dummy_env::dummy_with(self.lock_time, self.sequence, self.include_fee_output);
-            mac.exec(self.program.redeem(), &env).map(|_| ())
+        fn run(self) -> Result<(), SimplicityErr> {
+            let (program_bytes, witness_bytes) = self.program.redeem().encode_to_vec();
+            let _ = run_program(&program_bytes, &witness_bytes, TestUpTo::Everything)?;
+            Ok(())
         }
 
         pub fn assert_run_success(self) {
@@ -425,7 +424,7 @@ mod tests {
         let mut t = TestCase::program_file("./examples/non_interactive_fee_bump.simf")
             .with_witness_file("./examples/non_interactive_fee_bump.wit");
         t.sequence = elements::Sequence::ENABLE_LOCKTIME_NO_RBF;
-        t.lock_time = LockTime::from_time(1734967235 + 600).unwrap();
+        t.lock_time = elements::LockTime::from_time(1734967235 + 600).unwrap();
         t.include_fee_output = true;
         t.assert_run_success();
     }
@@ -613,8 +612,22 @@ fn main() {
 fn main() {
     let x: MyAlias = 32;
     assert!(jet::eq_32(x, 32));
-}
-"#;
+}"#;
+        TestCase::program_text(Cow::Borrowed(prog_text))
+            .with_witness_values(WitnessValues::default())
+            .assert_run_success();
+    }
+
+    #[test]
+    fn type_error_regression() {
+        let prog_text = r#"fn main() {
+    let (a, b): (u32, u32) = (0, 1);
+    assert!(jet::eq_32(a, 0));
+
+    let (c, d): (u32, u32) = (2, 3);
+    assert!(jet::eq_32(c, 2));
+    assert!(jet::eq_32(d, 3));
+}"#;
         TestCase::program_text(Cow::Borrowed(prog_text))
             .with_witness_values(WitnessValues::default())
             .assert_run_success();

src/lib.rs

@@ -3,12 +3,12 @@ use std::sync::Arc;
 use simplicity::dag::{InternalSharing, PostOrderIterItem};
 use simplicity::jet::{Elements, Jet};
 use simplicity::node::{
-    self, CommitData, Constructible, Converter, CoreConstructible, Inner, JetConstructible,
-    NoDisconnect, NoWitness, Node, WitnessConstructible, WitnessData,
+    self, CommitData, ConstructData as WitnessData, Constructible, Converter, CoreConstructible,
+    Inner, JetConstructible, NoDisconnect, NoWitness, Node, WitnessConstructible,
 };
 use simplicity::types::arrow::Arrow;
 use simplicity::{types, CommitNode, FailEntropy};
-use simplicity::{Cmr, WitnessNode};
+use simplicity::{Cmr, ConstructNode as WitnessNode};
 
 use crate::str::WitnessName;
 use crate::value::StructuralValue;
@@ -105,7 +105,7 @@ pub fn to_witness_node(node: &ConstructNode, values: WitnessValues) -> Arc<Witne
         inference_context: types::Context,
     }
 
-    impl<J: Jet> Converter<Construct<J>, node::Witness<J>> for Populator {
+    impl<J: Jet> Converter<Construct<J>, node::Construct<J>> for Populator {
         type Error = ();
 
         fn convert_witness(

src/named.rs

@@ -2,10 +2,10 @@ use std::fmt;
 use std::sync::Arc;
 
 use either::Either;
-use hex_conservative::DisplayHex;
+use miniscript::bitcoin::hex::DisplayHex;
 use miniscript::iter::{Tree, TreeLike};
 use simplicity::types::Final as SimType;
-use simplicity::{BitCollector, Value as SimValue};
+use simplicity::{BitCollector, Value as SimValue, ValueRef};
 
 use crate::array::{BTreeSlice, Combiner, Partition, Unfolder};
 use crate::error::{Error, RichError, WithSpan};
@@ -623,7 +623,7 @@ impl Value {
 
     /// Create a value from the given `hexadecimal` string and type.
     pub fn parse_hexadecimal(hexadecimal: &Hexadecimal, ty: &ResolvedType) -> Result<Self, Error> {
-        use hex_conservative::FromHex;
+        use miniscript::bitcoin::hex::FromHex;
 
         let expected_byte_len = match ty.as_inner() {
             TypeInner::UInt(int) => int.byte_width(),
@@ -730,11 +730,11 @@ impl Value {
     pub fn reconstruct(value: &StructuralValue, ty: &ResolvedType) -> Option<Self> {
         let mut output = vec![];
         for data in value.destruct(ty).post_order_iter() {
+            let size = data.node.n_children();
             let (value, ty) = match data.node {
                 Destructor::Ok { value, ty } => (value, ty),
                 Destructor::WrongType => return None,
             };
-            let size = data.node.n_children();
             match ty.as_inner() {
                 TypeInner::Boolean => {
                     let bit = destruct::as_bit(value)?;
@@ -877,10 +877,10 @@ impl TreeLike for StructuralValue {
     fn as_node(&self) -> Tree<Self> {
         use simplicity::dag::{Dag, DagLike};
 
-        match (&self.0).as_dag_node() {
+        match self.0.as_ref().as_dag_node() {
             Dag::Nullary => Tree::Nullary,
-            Dag::Unary(l) => Tree::Unary(Self(l.shallow_clone())),
-            Dag::Binary(l, r) => Tree::Binary(Self(l.shallow_clone()), Self(r.shallow_clone())),
+            Dag::Unary(l) => Tree::Unary(Self(l.to_value())),
+            Dag::Binary(l, r) => Tree::Binary(Self(l.to_value()), Self(r.to_value())),
         }
     }
 }
@@ -1059,7 +1059,7 @@ impl StructuralValue {
 
     fn destruct<'a>(&'a self, ty: &'a ResolvedType) -> Destructor<'a> {
         Destructor::Ok {
-            value: self.as_ref(),
+            value: self.0.as_ref(),
             ty,
         }
     }
@@ -1091,30 +1091,30 @@ impl StructuralValue {
 /// The leaf values (Boolean, unsigned integer, empty tuple, empty array) are not checked.
 /// Extraction of actual Simfony values (Boolean, unsigned integer, ...)
 /// from the leaf Simplicity values may fail, in which case the entire tree is, again, ill-typed.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug)]
 enum Destructor<'a> {
     Ok {
-        value: &'a SimValue,
+        value: ValueRef<'a>,
         ty: &'a ResolvedType,
     },
     WrongType,
 }
 
 impl<'a> Destructor<'a> {
     /// Create a destructor for the given Simplicity `value` and the given Simfony type.
-    pub const fn new(value: &'a SimValue, ty: &'a ResolvedType) -> Self {
+    pub const fn new(value: ValueRef<'a>, ty: &'a ResolvedType) -> Self {
         Self::Ok { value, ty }
     }
 
-    const fn new_pair((value, ty): (&'a SimValue, &'a ResolvedType)) -> Self {
+    const fn new_pair((value, ty): (ValueRef<'a>, &'a ResolvedType)) -> Self {
         Self::Ok { value, ty }
     }
 }
 
 impl TreeLike for Destructor<'_> {
     fn as_node(&self) -> Tree<Self> {
         let (value, ty) = match self {
-            Self::Ok { value, ty } => (value, ty),
+            Self::Ok { value, ty } => (value.clone(), ty),
             Self::WrongType => return Tree::Nullary,
         };
         match ty.as_inner() {
@@ -1166,8 +1166,9 @@ impl TreeLike for Destructor<'_> {
 /// Functions for destructing Simplicity values alongside Simfony types.
 mod destruct {
     use super::*;
+    use simplicity::ValueRef;
 
-    pub fn as_bit(value: &SimValue) -> Option<bool> {
+    pub fn as_bit(value: ValueRef) -> Option<bool> {
         match value.as_left() {
             Some(unit) if unit.is_unit() => Some(false),
             _ => match value.as_right() {
@@ -1177,10 +1178,10 @@ mod destruct {
         }
     }
 
-    pub fn as_integer(value: &SimValue, ty: UIntType) -> Option<UIntValue> {
+    pub fn as_integer(value: ValueRef, ty: UIntType) -> Option<UIntValue> {
         let bit_len = ty.bit_width().get();
         let unfolder = Unfolder::new(value, bit_len);
-        let bit_values = unfolder.unfold(SimValue::as_product)?;
+        let bit_values = unfolder.unfold(|v| v.as_product())?;
         let (bytes, written_bits) = bit_values.into_iter().filter_map(as_bit).collect_bits();
         if bit_len != written_bits {
             return None;
@@ -1196,31 +1197,31 @@ mod destruct {
         }
     }
 
-    pub fn as_tuple(value: &SimValue, size: usize) -> Option<Vec<&SimValue>> {
-        Unfolder::new(value, size).unfold(SimValue::as_product)
+    pub fn as_tuple(value: ValueRef, size: usize) -> Option<Vec<ValueRef>> {
+        Unfolder::new(value, size).unfold(|v| v.as_product())
     }
 
-    pub fn as_array(value: &SimValue, size: usize) -> Option<Vec<&SimValue>> {
-        Unfolder::new(value, size).unfold(SimValue::as_product)
+    pub fn as_array(value: ValueRef, size: usize) -> Option<Vec<ValueRef>> {
+        Unfolder::new(value, size).unfold(|v| v.as_product())
     }
 
-    pub fn as_list<'a>(value: &'a SimValue, bound: NonZeroPow2Usize) -> Option<Vec<&'a SimValue>> {
-        let as_block = |value: &'a SimValue, size: usize| match as_option(value) {
+    pub fn as_list<'a>(value: ValueRef<'a>, bound: NonZeroPow2Usize) -> Option<Vec<ValueRef<'a>>> {
+        let as_block = |value: ValueRef<'a>, size: usize| match as_option(value) {
             Some(Some(folded)) => as_array(folded, size),
             Some(None) => Some(vec![]),
             None => None,
         };
-        Combiner::new(value, bound).unfold(as_block, SimValue::as_product)
+        Combiner::new(value, bound).unfold(as_block, |v| v.as_product())
     }
 
-    pub fn as_either(value: &SimValue) -> Option<Either<&SimValue, &SimValue>> {
+    pub fn as_either(value: ValueRef) -> Option<Either<ValueRef, ValueRef>> {
         match value.as_left() {
             Some(inner) => Some(Either::Left(inner)),
             None => value.as_right().map(Either::Right),
         }
     }
 
-    pub fn as_option(value: &SimValue) -> Option<Option<&SimValue>> {
+    pub fn as_option(value: ValueRef) -> Option<Option<ValueRef>> {
         match value.as_left() {
             Some(inner) if inner.is_unit() => Some(None),
             _ => value.as_right().map(Some),