Merge #35: bump rust-simplicity to 0.7; update simplicity pset run

23a150c bump rust-simplicity to 0.7; update `simplicity pset run` (Andrew Poelstra)

Pull request description:

  We retain the existing "only log jets in `simplicity pset run`" behavior, although we now have the ability to log every node. My expectation is that in practice users will usually only care about the flow of data between jets. We can add extensions later to improve this.
  
  Meanwhile, this greatly improves the output; rather than doing a hex dump we output a full value decode which distinguishes left and right sums and so on. We also split up the inputs to the eq_1 and eq_2 jets which we previously didn't do because they'd be less than one hex nybble.


ACKs for top commit:
  delta1:
    ACK 23a150c 


Tree-SHA512: 23768c22795a81ac453dc667b6bbba257129936d80cf670f40135a421085eac774d5aecd3ca0175f4690bad6f45771b08bd6aac6795c6e867974ff4cec346531

Author: apoelstra

Cargo.lock

@@ -31,7 +31,7 @@ serde_yaml = "0.8.8"
 hex = "0.3.2"
 
 elements = { version = "0.25.2", features = [ "serde", "base64" ] }
-simplicity = { package = "simplicity-lang", version = "0.5.0", features = [ "base64", "serde" ] }
+simplicity = { package = "simplicity-lang", version = "0.7.0", features = [ "base64", "serde" ] }
 thiserror = "2.0.17"
 
 [lints.clippy]

Cargo.toml

@@ -4,9 +4,9 @@
 use serde::Serialize;
 
 use crate::hal_simplicity::Program;
-use crate::simplicity::bit_machine::{BitMachine, ExecTracker};
-use crate::simplicity::jet;
-use crate::simplicity::{Cmr, Ihr};
+use crate::simplicity::bit_machine::{BitMachine, ExecTracker, FrameIter, NodeOutput};
+use crate::simplicity::Value;
+use crate::simplicity::{jet, node};
 
 use super::{execution_environment, PsetError};
 
@@ -37,8 +37,8 @@ pub struct JetCall {
 	pub source_ty: String,
 	pub target_ty: String,
 	pub success: bool,
-	pub input_hex: String,
-	pub output_hex: String,
+	pub input_value: String,
+	pub output_value: String,
 	#[serde(skip_serializing_if = "Option::is_none")]
 	pub equality_check: Option<(String, String)>,
 }
@@ -52,56 +52,44 @@ pub struct RunResponse {
 struct JetTracker(Vec<JetCall>);
 
 impl<J: jet::Jet> ExecTracker<J> for JetTracker {
-	fn track_left(&mut self, _: Ihr) {}
-	fn track_right(&mut self, _: Ihr) {}
-	fn track_jet_call(
+	fn visit_node(
 		&mut self,
-		jet: &J,
-		input_buffer: &[simplicity::ffi::ffi::UWORD],
-		output_buffer: &[simplicity::ffi::ffi::UWORD],
-		success: bool,
+		node: &simplicity::RedeemNode<J>,
+		mut input: FrameIter,
+		output: NodeOutput,
 	) {
-		// The word slices are in reverse order for some reason.
-		// FIXME maybe we should attempt to parse out Simplicity values here which
-		//    can often be displayed in a better way, esp for e.g. option types.
-		let mut input_hex = String::new();
-		for word in input_buffer.iter().rev() {
-			for byte in word.to_be_bytes() {
-				input_hex.push_str(&format!("{:02x}", byte));
-			}
+		if let node::Inner::Jet(jet) = node.inner() {
+			let input_value = Value::from_padded_bits(&mut input, &node.arrow().source)
+				.expect("valid value from bit machine");
+
+			let (success, output_value) = match output {
+				NodeOutput::NonTerminal => unreachable!(),
+				NodeOutput::JetFailed => (false, Value::unit()),
+				NodeOutput::Success(mut iter) => (
+					true,
+					Value::from_padded_bits(&mut iter, &node.arrow().target)
+						.expect("valid value from bit machine"),
+				),
+			};
+
+			let jet_name = jet.to_string();
+			let equality_check = if jet_name.strip_prefix("eq_").is_some() {
+				let (left, right) = input_value.as_product().unwrap();
+				Some((left.to_value().to_string(), right.to_value().to_string()))
+			} else {
+				None
+			};
+
+			self.0.push(JetCall {
+				jet: jet_name,
+				source_ty: jet.source_ty().to_final().to_string(),
+				target_ty: jet.target_ty().to_final().to_string(),
+				success,
+				input_value: input_value.to_string(),
+				output_value: output_value.to_string(),
+				equality_check,
+			});
 		}
-
-		let mut output_hex = String::new();
-		for word in output_buffer.iter().rev() {
-			for byte in word.to_be_bytes() {
-				output_hex.push_str(&format!("{:02x}", byte));
-			}
-		}
-
-		let jet_name = jet.to_string();
-		let equality_check = match jet_name.as_str() {
-			"eq_1" => None, // FIXME parse bits out of input
-			"eq_2" => None, // FIXME parse bits out of input
-			x if x.strip_prefix("eq_").is_some() => {
-				let split = input_hex.split_at(input_hex.len() / 2);
-				Some((split.0.to_owned(), split.1.to_owned()))
-			}
-			_ => None,
-		};
-		self.0.push(JetCall {
-			jet: jet_name,
-			source_ty: jet.source_ty().to_final().to_string(),
-			target_ty: jet.target_ty().to_final().to_string(),
-			success,
-			input_hex,
-			output_hex,
-			equality_check,
-		});
-	}
-
-	fn track_dbg_call(&mut self, _: &Cmr, _: simplicity::Value) {}
-	fn is_track_debug_enabled(&self) -> bool {
-		false
 	}
 }