Reduce trace build inputs for prove-from-trace

CHANGELOG.md

@@ -20,6 +20,7 @@
 - [BREAKING] Removed the deprecated `FastProcessor::execute_for_trace_sync()` and `execute_for_trace()` wrappers; use `execute_trace_inputs_sync()` or `execute_trace_inputs()` instead ([#2865](https://github.com/0xMiden/miden-vm/pull/2865)).
 - [BREAKING] Removed the deprecated unbound `TraceBuildInputs::new()` and `TraceBuildInputs::from_program()` constructors; use `execute_trace_inputs_sync()` or `execute_trace_inputs()` instead ([#2865](https://github.com/0xMiden/miden-vm/pull/2865)).
 - Added `prove_from_trace_sync(...)` for proving from pre-executed trace inputs ([#2865](https://github.com/0xMiden/miden-vm/pull/2865)).
+- [BREAKING] Reduced the prove-from-trace API to post-execution trace inputs: `TraceBuildInputs` no longer carries full execution output, `prove_from_trace_sync()` takes `TraceProvingInputs`, and `ProvingOptions` no longer include `ExecutionOptions` ([#2948](https://github.com/0xMiden/miden-vm/pull/2948)).
 - Refactor trace generation to row-major format ([#2937](https://github.com/0xMiden/miden-vm/pull/2937)).
 
 #### Fixes

crates/lib/core/tests/crypto/ecdsa_k256_keccak.rs

@@ -68,14 +68,14 @@ fn test_ecdsa_verify_cases() {
         );
 
         let test = build_debug_test!(source, &[]);
-        let output = test.execute().unwrap();
+        let (output, _) = test.execute_for_output().unwrap();
 
         // Assert result
-        let result = output.stack_outputs().get_element(0).unwrap();
+        let result = output.stack.get_element(0).unwrap();
         assert_eq!(result, Felt::from_bool(expected_valid));
 
         // Verify the precompile request was logged with the right event ID
-        let deferred = output.advice_provider().precompile_requests().to_vec();
+        let deferred = output.advice.precompile_requests().to_vec();
         assert_eq!(deferred.len(), 1);
         assert_eq!(deferred[0], request.as_precompile_request());
     }
@@ -112,8 +112,8 @@ fn test_ecdsa_verify_impl_commitment() {
         );
 
         let test = build_debug_test!(source, &[]);
-        let output = test.execute().unwrap();
-        let stack = output.stack_outputs();
+        let (output, _) = test.execute_for_output().unwrap();
+        let stack = output.stack;
 
         // Verify stack layout: [COMM (0-3), TAG (4-7), result (at position 8), ...]
         // TAG = [event_id, result, 0, 0] where TAG[1]=result is at position 5
@@ -137,11 +137,11 @@ fn test_ecdsa_verify_impl_commitment() {
             "result does not match expected validity"
         );
 
-        let deferred = output.advice_provider().precompile_requests().to_vec();
+        let deferred = output.advice.precompile_requests().to_vec();
         assert_eq!(deferred.len(), 1, "expected a single deferred request");
         assert_eq!(deferred[0], request.as_precompile_request());
 
-        let advice_stack = output.advice_provider().stack();
+        let advice_stack = output.advice.stack();
         assert!(advice_stack.is_empty(), "advice stack should be empty after verify_impl");
     }
 }

crates/lib/core/tests/crypto/eddsa_ed25519.rs

@@ -66,12 +66,12 @@ fn test_eddsa_verify_prehash_cases() {
     );
 
     let test = build_debug_test!(source, &[]);
-    let output = test.execute().unwrap();
+    let (output, _) = test.execute_for_output().unwrap();
 
-    let result = output.stack_outputs().get_element(0).unwrap();
+    let result = output.stack.get_element(0).unwrap();
     assert_eq!(result, Felt::ONE, "verification result mismatch");
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1, "expected one deferred request");
     assert_eq!(deferred[0], valid_request.as_precompile_request());
 
@@ -94,12 +94,12 @@ fn test_eddsa_verify_prehash_cases() {
     );
 
     let test = build_debug_test!(source, &[]);
-    let output = test.execute().unwrap();
+    let (output, _) = test.execute_for_output().unwrap();
 
-    let result = output.stack_outputs().get_element(0).unwrap();
+    let result = output.stack.get_element(0).unwrap();
     assert_eq!(result, Felt::ZERO, "verification result mismatch");
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1, "expected one deferred request");
     assert_eq!(deferred[0], invalid_request.as_precompile_request());
 }
@@ -133,8 +133,8 @@ fn test_eddsa_verify_prehash_impl_commitment() {
         );
 
         let test = build_debug_test!(source, &[]);
-        let output = test.execute().unwrap();
-        let stack = output.stack_outputs();
+        let (output, _) = test.execute_for_output().unwrap();
+        let stack = output.stack;
 
         let commitment = stack.get_word(0).unwrap();
         let tag = stack.get_word(4).unwrap();
@@ -148,12 +148,12 @@ fn test_eddsa_verify_prehash_impl_commitment() {
         let result = stack.get_element(5).unwrap();
         assert_eq!(result, Felt::from_bool(expected_valid));
 
-        let deferred = output.advice_provider().precompile_requests().to_vec();
+        let deferred = output.advice.precompile_requests().to_vec();
         assert_eq!(deferred.len(), 1, "expected a single deferred request");
         assert_eq!(deferred[0], request.as_precompile_request());
 
         assert!(
-            output.advice_provider().stack().is_empty(),
+            output.advice.stack().is_empty(),
             "advice stack should be empty after verify_prehash_impl"
         );
     }

crates/lib/core/tests/crypto/keccak256.rs

@@ -74,12 +74,12 @@ fn test_keccak_handler(input_u8: &[u8]) {
 
     let test = build_debug_test!(source, &[]);
 
-    let output = test.execute().unwrap();
+    let (output, _) = test.execute_for_output().unwrap();
 
-    let advice_stack = output.advice_provider().stack();
+    let advice_stack = output.advice.stack();
     assert_eq!(advice_stack, preimage.digest().as_ref());
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1, "advice deferred must contain one entry");
     let precompile_data = &deferred[0];
 
@@ -121,9 +121,9 @@ fn test_keccak_hash_bytes_impl(input_u8: &[u8]) {
 
     let test = build_debug_test!(source, &[]);
 
-    let output = test.execute().unwrap();
+    let (output, _) = test.execute_for_output().unwrap();
 
-    let stack = output.stack_outputs();
+    let stack = output.stack;
     let commitment = stack.get_word(0).unwrap();
     let tag = stack.get_word(4).unwrap();
     let precompile_commitment = PrecompileCommitment::new(tag, commitment);
@@ -134,13 +134,13 @@ fn test_keccak_hash_bytes_impl(input_u8: &[u8]) {
     let digest: [Felt; 8] = array::from_fn(|i| stack.get_element(8 + i).unwrap());
     assert_eq!(&digest, preimage.digest().as_ref(), "output digest does not match");
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1, "expected a single deferred request");
     assert_eq!(deferred[0].event_id(), KECCAK_HASH_BYTES_EVENT_NAME.to_event_id());
     assert_eq!(deferred[0].calldata(), preimage.as_ref());
     assert_eq!(deferred[0], preimage.into());
 
-    let advice_stack = output.advice_provider().stack();
+    let advice_stack = output.advice.stack();
     assert!(advice_stack.is_empty(), "advice stack should be empty after hash_bytes_impl");
 }
 

crates/lib/core/tests/crypto/sha512.rs

@@ -56,12 +56,12 @@ fn test_sha512_handler(bytes: &[u8]) {
     );
 
     let test = build_debug_test!(source, &[]);
-    let output = test.execute().unwrap();
+    let (output, _) = test.execute_for_output().unwrap();
 
-    let advice_stack: Vec<_> = output.advice_provider().stack().to_vec();
+    let advice_stack: Vec<_> = output.advice.stack().to_vec();
     assert_eq!(advice_stack, preimage.digest().as_ref());
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1);
     let request = &deferred[0];
     assert_eq!(request.calldata(), preimage.as_ref());
@@ -90,13 +90,13 @@ fn test_sha512_hash_memory_impl(bytes: &[u8]) {
     );
 
     let test = build_debug_test!(source, &[]);
-    let output = test.execute().unwrap();
-    let stack = output.stack_outputs();
+    let (output, _) = test.execute_for_output().unwrap();
+    let stack = &output.stack;
 
     // we cannot check the digest since it overflows the stack.
     // we check it in test_sha512_hash_memory
 
-    let deferred = output.advice_provider().precompile_requests().to_vec();
+    let deferred = output.advice.precompile_requests().to_vec();
     assert_eq!(deferred.len(), 1);
     let request = &deferred[0];
     assert_eq!(request.event_id(), SHA512_HASH_BYTES_EVENT_NAME.to_event_id());
@@ -111,7 +111,7 @@ fn test_sha512_hash_memory_impl(bytes: &[u8]) {
     assert_eq!(precompile_commitment, verifier_commitment, "commitment mismatch");
 
     assert!(
-        output.advice_provider().stack().is_empty(),
+        output.advice.stack().is_empty(),
         "advice stack must be empty after hash_memory_impl"
     );
 }

crates/lib/core/tests/stark/mod.rs

@@ -8,7 +8,7 @@ use miden_core::{
     precompile::PrecompileTranscriptState,
     proof::HashFunction,
 };
-use miden_processor::{DefaultHost, Program, ProgramInfo};
+use miden_processor::{DefaultHost, ExecutionOptions, Program, ProgramInfo};
 use miden_utils_testing::{AdviceInputs, ProvingOptions, StackInputs, prove_sync};
 use rand::{Rng, RngCore, SeedableRng};
 use rand_chacha::ChaCha20Rng;
@@ -105,8 +105,15 @@ pub fn generate_recursive_verifier_data(
 
     let options = ProvingOptions::new(HashFunction::Poseidon2);
 
-    let (stack_outputs, proof) =
-        prove_sync(&program, stack_inputs, advice_inputs, &mut host, options).unwrap();
+    let (stack_outputs, proof) = prove_sync(
+        &program,
+        stack_inputs,
+        advice_inputs,
+        &mut host,
+        ExecutionOptions::default(),
+        options,
+    )
+    .unwrap();
 
     let program_info = ProgramInfo::from(program);
 

crates/lib/core/tests/sys/mod.rs

@@ -13,7 +13,7 @@ use miden_core::{
 };
 use miden_core_lib::CoreLibrary;
 use miden_processor::{
-    DefaultHost, ProcessorState, Program, StackInputs,
+    DefaultHost, ExecutionOptions, ProcessorState, Program, StackInputs,
     advice::{AdviceInputs, AdviceMutation},
     event::{EventError, EventHandler},
 };
@@ -158,9 +158,15 @@ fn log_precompile_request_procedure() {
         .expect("failed to register dummy handler");
 
     let options = ProvingOptions::with_96_bit_security(HashFunction::Blake3_256);
-    let (stack_outputs, proof) =
-        miden_utils_testing::prove_sync(&program, stack_inputs, advice_inputs, &mut host, options)
-            .expect("failed to generate proof for log_precompile helper");
+    let (stack_outputs, proof) = miden_utils_testing::prove_sync(
+        &program,
+        stack_inputs,
+        advice_inputs,
+        &mut host,
+        ExecutionOptions::default(),
+        options,
+    )
+    .expect("failed to generate proof for log_precompile helper");
 
     // Proof should include the single deferred request that we expect.
     assert_eq!(proof.precompile_requests().len(), 1);
@@ -185,15 +191,15 @@ fn log_precompile_request_procedure() {
     );
 
     let program_info = ProgramInfo::from(program);
-    let (_, transcript_digest) = miden_verifier::verify_with_precompiles(
+    let (_, pc_transcript_digest) = miden_verifier::verify_with_precompiles(
         program_info,
         stack_inputs,
         stack_outputs,
         proof,
         &verifier_registry,
     )
     .expect("proof verification with precompiles failed");
-    assert_eq!(transcript.finalize(), transcript_digest);
+    assert_eq!(transcript.finalize(), pc_transcript_digest);
 }
 
 #[derive(Clone)]

crates/test-utils/src/lib.rs

@@ -493,6 +493,7 @@ impl Test {
             stack_inputs,
             self.advice_inputs.clone(),
             &mut host,
+            miden_processor::ExecutionOptions::default(),
             ProvingOptions::default(),
         )
         .unwrap();
@@ -628,7 +629,7 @@ impl Test {
         };
 
         compare_results(
-            fast_result.as_ref().map(|trace_inputs| trace_inputs.execution_output().stack),
+            fast_result.as_ref().map(|trace_inputs| *trace_inputs.stack_outputs()),
             &fast_result_by_step,
             "fast processor",
             "fast processor by step",

miden-vm/README.md

@@ -92,8 +92,10 @@ callers. `prove_sync()` takes the following arguments:
 
 - `program: &Program` - a reference to a Miden program to be executed.
 - `stack_inputs: StackInputs` - a set of public inputs with which to execute the program.
+- `advice_inputs: AdviceInputs` - the initial nondeterministic inputs available to the VM.
 - `host: Host` - an instance of a `Host` which can be used to supply non-deterministic inputs to the VM and receive messages from the VM.
-- `options: ProvingOptions` - config parameters for proof generation. The default options target 96-bit security level.
+- `execution_options: ExecutionOptions` - VM execution parameters such as cycle limits and trace fragmentation.
+- `options: ProvingOptions` - proof-generation parameters. The default options target 96-bit security level.
 
 If the program is executed successfully, the function returns a tuple with 2 elements:
 
@@ -110,7 +112,7 @@ use miden_vm::{
     advice::AdviceInputs,
     assembly::DefaultSourceManager,
     field::PrimeField64,
-    Assembler, DefaultHost, ProvingOptions, Program, prove_sync, StackInputs
+    Assembler, DefaultHost, ExecutionOptions, ProvingOptions, Program, prove_sync, StackInputs
 };
 
 // instantiate the assembler
@@ -125,6 +127,7 @@ let (outputs, proof) = prove_sync(
     StackInputs::default(),       // we won't provide any inputs
     AdviceInputs::default(),      // we don't need any initial advice inputs
     &mut DefaultHost::default(),  // we'll be using a default host
+    ExecutionOptions::default(),  // we'll use default VM execution options
     ProvingOptions::default(),    // we'll be using default options
 )
 .unwrap();
@@ -226,6 +229,7 @@ let (outputs, proof) = miden_vm::prove_sync(
     stack_inputs,
     AdviceInputs::default(), // without initial advice inputs
     &mut host,
+    miden_vm::ExecutionOptions::default(), // use default VM execution options
     ProvingOptions::default(), // use default proving options
 )
 .unwrap();

miden-vm/src/cli/prove.rs

@@ -69,16 +69,18 @@ pub struct ProveCmd {
 }
 
 impl ProveCmd {
-    pub fn get_proof_options(&self) -> Result<ProvingOptions, Report> {
-        let exec_options = ExecutionOptions::new(
+    pub fn get_execution_options(&self) -> Result<ExecutionOptions, Report> {
+        ExecutionOptions::new(
             Some(self.max_cycles),
             self.expected_cycles,
             ExecutionOptions::DEFAULT_CORE_TRACE_FRAGMENT_SIZE,
             self.trace,
             !self.release,
         )
-        .map_err(|err| Report::msg(format!("{err}")))?;
+        .map_err(|err| Report::msg(format!("{err}")))
+    }
 
+    pub fn get_proof_options(&self) -> Result<ProvingOptions, Report> {
         let hash_fn = HashFunction::try_from(self.hasher.as_str())
             .map_err(|err| Report::msg(format!("{err}")))?;
         let proving_options = match self.security.as_str() {
@@ -89,7 +91,7 @@ impl ProveCmd {
                 )));
             },
         };
-        Ok(proving_options.with_execution_options(exec_options))
+        Ok(proving_options)
     }
     pub fn execute(&self) -> Result<(), Report> {
         println!("===============================================================================");
@@ -143,6 +145,7 @@ impl ProveCmd {
         let stack_inputs = input_data.parse_stack_inputs().map_err(Report::msg)?;
         let advice_inputs = input_data.parse_advice_inputs().map_err(Report::msg)?;
 
+        let execution_options = self.get_execution_options()?;
         let proving_options = self.get_proof_options()?;
 
         // execute program and generate proof
@@ -151,6 +154,7 @@ impl ProveCmd {
             stack_inputs,
             advice_inputs,
             &mut host,
+            execution_options,
             proving_options,
         )
         .wrap_err("Failed to prove program")?;

miden-vm/src/lib.rs

@@ -18,7 +18,7 @@ pub use miden_processor::{
     TraceGenerationContext, ZERO, advice, crypto, execute, field, operation::Operation, serde,
     trace, trace::ExecutionTrace, utils,
 };
-pub use miden_prover::{InputError, ProvingOptions, StackOutputs, Word, prove};
+pub use miden_prover::{InputError, ProvingOptions, StackOutputs, TraceProvingInputs, Word, prove};
 #[cfg(not(target_arch = "wasm32"))]
 pub use miden_prover::{prove_from_trace_sync, prove_sync};
 pub use miden_verifier::VerificationError;