Merge branch 'main' into modular_precompiles

Author: TomWambsgans

crates/lean_compiler/src/lib.rs

@@ -24,8 +24,10 @@ pub fn compile_program(program: String) -> Bytecode {
     // for (loc, name) in function_locations.iter() {
     //     println!("{name}: {loc}");
     // }
+    /* let compiled = */
+    compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap() // ;
     // println!("\n\nCompiled Program:\n\n{compiled}");
-    compile_to_low_level_bytecode(intermediate_bytecode, program, function_locations).unwrap()
+    // compiled
 }
 
 pub fn compile_and_run(

crates/lean_prover/tests/test_zkvm.rs

@@ -191,6 +191,6 @@ fn test_zk_vm_helper(
     );
     let proof_time = time.elapsed();
     verify_execution(&bytecode, public_input, proof, whir_config_builder()).unwrap();
-    println!("{}", summary);
+    println!("{summary}");
     println!("Proof time: {:.3} s", proof_time.as_secs_f32());
 }

crates/lean_vm/src/diagnostics/error.rs

@@ -9,8 +9,12 @@ pub enum RunnerError {
     #[error("Out of memory")]
     OutOfMemory,
 
-    #[error("Memory already set")]
-    MemoryAlreadySet,
+    #[error("Memory already set: m[{address}] = {prev_value} != {new_value}")]
+    MemoryAlreadySet {
+        address: usize,
+        prev_value: F,
+        new_value: F,
+    },
 
     #[error("Not a pointer")]
     NotAPointer,

crates/lean_vm/src/diagnostics/stack_trace.rs

@@ -10,6 +10,7 @@ pub(crate) fn pretty_stack_trace(
     source_code: &str,
     instructions: &[SourceLineNumber], // SourceLineNumber = usize
     function_locations: &BTreeMap<usize, String>,
+    last_pc: usize,
 ) -> String {
     let source_lines: Vec<&str> = source_code.lines().collect();
     let mut result = String::new();
@@ -97,7 +98,11 @@ pub(crate) fn pretty_stack_trace(
     if !call_stack.is_empty() {
         result.push_str("\nCall stack:\n");
         for (i, (line, func)) in call_stack.iter().enumerate() {
-            result.push_str(&format!("  {}. {} (line {})\n", i + 1, func, line));
+            if i + 1 == call_stack.len() {
+                result.push_str(&format!("  {}. {} (line {}, pc {})\n", i + 1, func, line, last_pc));
+            } else {
+                result.push_str(&format!("  {}. {} (line {})\n", i + 1, func, line));
+            }
         }
     }
 

crates/lean_vm/src/execution/memory.rs

@@ -41,7 +41,11 @@ impl Memory {
         }
         if let Some(existing) = &mut self.0[index] {
             if *existing != value {
-                return Err(RunnerError::MemoryAlreadySet);
+                return Err(RunnerError::MemoryAlreadySet {
+                    address: index,
+                    prev_value: *existing,
+                    new_value: value,
+                });
             }
         } else {
             self.0[index] = Some(value);

crates/lean_vm/src/execution/runner.rs

@@ -71,15 +71,16 @@ pub fn execute_bytecode(
         (poseidons_16_precomputed, poseidons_24_precomputed),
         merkle_path_hints,
     )
-    .unwrap_or_else(|err| {
+    .unwrap_or_else(|(last_pc, err)| {
         let lines_history = &instruction_history.lines;
         let latest_instructions = &lines_history[lines_history.len().saturating_sub(STACK_TRACE_INSTRUCTIONS)..];
         println!(
             "\n{}",
             crate::diagnostics::pretty_stack_trace(
                 &bytecode.program,
                 latest_instructions,
-                &bytecode.function_locations
+                &bytecode.function_locations,
+                last_pc
             )
         );
         if !std_out.is_empty() {
@@ -148,15 +149,15 @@ fn execute_bytecode_helper(
     profiling: bool,
     (poseidons_16_precomputed, poseidons_24_precomputed): (&Poseidon16History, &Poseidon24History),
     mut merkle_path_hints: VecDeque<Vec<[F; 8]>>,
-) -> Result<ExecutionResult, RunnerError> {
+) -> Result<ExecutionResult, (CodeAddress, RunnerError)> {
     // set public memory
     let mut memory = Memory::new(build_public_memory(public_input));
 
     let public_memory_size = (NONRESERVED_PROGRAM_INPUT_START + public_input.len()).next_power_of_two();
     let mut fp = public_memory_size;
 
     for (i, value) in private_input.iter().enumerate() {
-        memory.set(fp + i, *value)?;
+        memory.set(fp + i, *value).expect("to set private input in memory");
     }
 
     let mut mem_profile = MemoryProfile {
@@ -200,7 +201,7 @@ fn execute_bytecode_helper(
 
     while pc != ENDING_PC {
         if pc >= bytecode.instructions.len() {
-            return Err(RunnerError::PCOutOfBounds);
+            return Err((pc, RunnerError::PCOutOfBounds));
         }
 
         pcs.push(pc);
@@ -227,7 +228,7 @@ fn execute_bytecode_helper(
                 profiling,
                 memory_profile: &mut mem_profile,
             };
-            hint.execute_hint(&mut hint_ctx)?;
+            hint.execute_hint(&mut hint_ctx).map_err(|e| (pc, e))?;
         }
 
         let instruction = &bytecode.instructions[pc];
@@ -247,7 +248,9 @@ fn execute_bytecode_helper(
             n_poseidon16_precomputed_used: &mut n_poseidon16_precomputed_used,
             n_poseidon24_precomputed_used: &mut n_poseidon24_precomputed_used,
         };
-        instruction.execute_instruction(&mut instruction_ctx)?;
+        instruction
+            .execute_instruction(&mut instruction_ctx)
+            .map_err(|e| (pc, e))?;
     }
 
     assert_eq!(

crates/lean_vm/src/execution/tests.rs

@@ -25,7 +25,14 @@ fn test_memory_already_set_error() {
     memory.set(0, F::ONE).unwrap();
 
     // Setting different value should fail
-    assert!(matches!(memory.set(0, F::ZERO), Err(RunnerError::MemoryAlreadySet)));
+    assert!(matches!(
+        memory.set(0, F::ZERO),
+        Err(RunnerError::MemoryAlreadySet {
+            address: 0,
+            prev_value: F::ONE,
+            new_value: F::ZERO,
+        })
+    ));
 }
 
 #[test]

crates/rec_aggregation/src/xmss_aggregate.rs

@@ -232,6 +232,7 @@ pub fn xmss_verify_aggregated_signatures(
     proof_bytes: &[u8],
     slot: u64,
 ) -> Result<(), ProofError> {
+    let _ = slot; // TODO
     let program = get_xmss_aggregation_program();
 
     let proof = info_span!("Proof deserialization")