Fix run return value, print test cost bounds

Author: m-kus

src/commands/run.rs

@@ -52,6 +52,12 @@ pub enum Logging {
 }
 
 pub fn run(args: RunArgs) -> Result<()> {
+    let res = run_inner(args)?;
+    println!("{}", res);
+    Ok(())
+}
+
+pub(crate) fn run_inner(args: RunArgs) -> Result<String> {
     let witness = if let Some(witness_path) = args.build.witness {
         load_witness(Some(&witness_path))?
     } else {
@@ -78,26 +84,31 @@ pub fn run(args: RunArgs) -> Result<()> {
         false,
     );
 
-    if let Some(logging) = args.logging {
+    let res = if let Some(logging) = args.logging {
         let mut machine = BitMachine::for_program(node)?;
         let mut tracker = tracker::Tracker {
             debug_symbols: satisfied.debug_symbols(),
             debug_logs: logging >= Logging::Debug,
             jet_traces: logging == Logging::Trace,
         };
         let res = machine.exec_with_tracker(node, &env, &mut tracker)?;
-        println!("Result: {}", res);
+        format!("Result: {}", res)
     } else {
         let (program_bytes, witness_bytes) = node.encode_to_vec();
-        run_program(
+        let output = run_program(
             &program_bytes,
             &witness_bytes,
             TestUpTo::Everything,
             None,
             Some(env.c_tx_env()),
         )
         .map_err(|e| anyhow::anyhow!("Failed to run program: {}", e))?;
-    }
+        output
+            .eval_result
+            .into_result()
+            .map_err(|e| anyhow::anyhow!("Program exited with error: {}", e))?;
+        format!("Cost bound: {}", output.cost_bound)
+    };
 
-    Ok(())
+    Ok(res)
 }

src/commands/sign.rs

@@ -1,7 +1,5 @@
 use anyhow::{Context, Result};
 use clap::Args;
-use elements::hashes::sha256;
-use elements::hashes::Hash as _;
 use elements::secp256k1_zkp::{
     rand::rngs::OsRng, Keypair, Message, Secp256k1, SecretKey, XOnlyPublicKey,
 };
@@ -23,8 +21,7 @@ pub fn sign(args: SignArgs) -> Result<()> {
     let msg_bytes = Vec::from_hex(&args.message).with_context(|| "Failed to decode message hex")?;
     anyhow::ensure!(!msg_bytes.is_empty(), "Message must not be empty");
 
-    let digest = sha256::Hash::hash(&msg_bytes);
-    let msg = Message::from_digest_slice(digest.as_ref())
+    let msg = Message::from_digest_slice(msg_bytes.as_ref())
         .with_context(|| "Failed to construct message for signing")?;
 
     // Obtain or generate secret key

src/commands/test.rs

@@ -5,7 +5,8 @@ use std::path::PathBuf;
 use std::{fs, path::Path};
 use walkdir::WalkDir;
 
-use crate::commands::{run, BuildArgs, Logging, RunArgs};
+use crate::commands::run::run_inner;
+use crate::commands::{BuildArgs, Logging, RunArgs};
 
 // Colors for output
 const GREEN: &str = "\x1b[0;32m";
@@ -25,6 +26,7 @@ pub struct TestArgs {
 #[derive(Debug)]
 struct TestResult {
     name: String,
+    message: String,
     success: bool,
     error_message: Option<String>,
 }
@@ -54,7 +56,7 @@ pub fn test(args: TestArgs) -> Result<()> {
             let result = run_single_test(&file_path, &test_func, &test_name, &args)?;
 
             if result.success {
-                println!("{}ok{}", GREEN, NC);
+                println!("{}ok{} ({})", GREEN, NC, result.message);
                 passed_tests += 1;
             } else {
                 println!("{}err{}", RED, NC);
@@ -210,14 +212,16 @@ fn run_single_test(
     run_args.build.entrypoint = temp_file;
 
     // Call run function directly
-    match run(run_args) {
-        Ok(_) => Ok(TestResult {
+    match run_inner(run_args) {
+        Ok(res) => Ok(TestResult {
             name: test_name.to_string(),
+            message: res.to_lowercase(),
             success: true,
             error_message: None,
         }),
         Err(e) => Ok(TestResult {
             name: test_name.to_string(),
+            message: e.to_string(),
             success: false,
             // Use pretty Display with full context chain
             error_message: Some(format!("{:#}", e)),