This crate contains an implementation of Miden VM processor. The purpose of the processor is to execute a program and to generate a program execution trace. This trace is then used by Miden VM to generate a proof of correct execution of the program.
The processor provides multiple APIs depending on your use case:
The execute() function provides a convenient interface that executes a program and generates a complete execution trace:
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 private inputs used to build the advice provider with which to execute the program.host: &mut impl 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: ExecutionOptions- a set of options for executing the specified program (e.g., max allowed number of cycles).
The (async) function returns a Result<ExecutionTrace, ExecutionError> which will contain the execution trace of the program if the execution was successful, or an error if the execution failed.
For more control over execution and trace generation, you can use FastProcessor directly:
FastProcessor::execute()- Executes a program without any trace generation overhead. ReturnsExecutionOutputcontaining the final stack state and other execution results.FastProcessor::execute_for_trace()- Executes a program while collecting metadata for trace generation. Returns bothExecutionOutputandTraceGenerationContext.build_trace()- Takes theExecutionOutputandTraceGenerationContextfromexecute_for_trace()and constructs the full execution trace. When theconcurrentfeature is enabled, trace building is parallelized.
The processor is separated into two main components: execution and trace generation.
The FastProcessor is designed for fast program execution with minimal overhead. It can operate in two modes:
- Pure execution via
FastProcessor::execute(): Executes a program without generating any trace-related metadata. This mode is optimized for maximum performance when proof generation is not required. - Execution for trace generation via
FastProcessor::execute_for_trace(): Executes a program while collecting metadata required for subsequent trace generation. This metadata is encapsulated in aTraceGenerationContextthat is passed to thebuild_trace()function.
After execution with FastProcessor::execute_for_trace(), the build_trace() function uses the returned TraceGenerationContext to construct the full execution trace. When the concurrent feature is enabled, trace generation is parallelized for improved performance.
The trace consists of several sections:
- The decoder, which tracks instruction decoding and control flow.
- The stack, which records stack state transitions.
- The range-checker, which validates that values fit into 16 bits.
- The chiplets module, which handles complex computations (e.g., hashing) and random access memory.
These sections are connected via two buses:
- The range-checker bus, which links stack and chiplets modules with the range-checker.
- The chiplet bus, which links stack and the decoder with the chiplets module.
A much more in-depth description of Miden VM design is available here.
Miden processor can be compiled with the following features:
std- enabled by default and relies on the Rust standard library.concurrent- enables concurrency across certain parts of executiontesting- Enables APIs that can be helpful for testingbus-debugger- Used to debug our buses. Slows down the processor considerably.
To compile with no_std, disable default features via --no-default-features flag, in which case only the wasm32-unknown-unknown and wasm32-wasip1 targets are officially supported.
This project is dual-licensed under the MIT and Apache 2.0 licenses.