Struct ACVM

pub struct ACVM<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> {

    status: ACVMStatus<F>,
    backend: &'a B,
    block_solvers: HashMap<BlockId, MemoryOpSolver<F>>,
    opcodes: &'a [Opcode<F>],
    instruction_pointer: usize,
    witness_map: WitnessMap<F>,
    brillig_solver: Option<BrilligSolver<'a, F, B>>,
    acir_call_counter: usize,
    acir_call_results: Vec<Vec<F>>,
    unconstrained_functions: &'a [BrilligBytecode<F>],
    assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)],
    profiling_active: bool,
    profiling_samples: ProfilingSamples,
    brillig_fuzzing_active: bool,
    brillig_branch_to_feature_map: Option<&'a BranchToFeatureMap>,
    brillig_fuzzing_trace: Option<Vec<u32>>,
}

Fields

status: ACVMStatus<F>

backend: &'a B

block_solvers: HashMap<BlockId, MemoryOpSolver<F>>

Stores the solver for memory operations acting on blocks of memory disambiguated by block.

opcodes: &'a [Opcode<F>]

A list of opcodes which are to be executed by the ACVM.

instruction_pointer: usize

Index of the next opcode to be executed.

witness_map: WitnessMap<F>

A mapping of witnesses to their solved values The map is updated as the ACVM executes.

brillig_solver: Option<BrilligSolver<'a, F, B>>

acir_call_counter: usize

A counter maintained throughout an ACVM process that determines whether the caller has resolved the results of an ACIR call.

acir_call_results: Vec<Vec<F>>

Represents the outputs of all ACIR calls during an ACVM process List is appended onto by the caller upon reaching a ACVMStatus::RequiresAcirCall

unconstrained_functions: &'a [BrilligBytecode<F>]

assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)]

profiling_active: bool

profiling_samples: ProfilingSamples

brillig_fuzzing_active: bool

brillig_branch_to_feature_map: Option<&'a BranchToFeatureMap>

brillig_fuzzing_trace: Option<Vec<u32>>

Implementations

impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B>

pub fn new( backend: &'a B, opcodes: &'a [Opcode<F>], initial_witness: WitnessMap<F>, unconstrained_functions: &'a [BrilligBytecode<F>], assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)], ) -> Self

pub fn with_profiler(&mut self, profiling_active: bool)

pub fn with_brillig_fuzzing( &mut self, brillig_branch_to_feature_map: Option<&'a BranchToFeatureMap>, )

pub fn get_brillig_fuzzing_trace(&self) -> Option<Vec<u32>>

pub fn witness_map(&self) -> &WitnessMap<F>

Returns a reference to the current state of the ACVM’s WitnessMap.

Once execution has completed, the witness map can be extracted using ACVM::finalize

pub fn overwrite_witness(&mut self, witness: Witness, value: F) -> Option<F>

pub fn opcodes(&self) -> &[Opcode<F>]

Returns a slice containing the opcodes of the circuit being executed.

pub fn instruction_pointer(&self) -> usize

Returns the index of the current opcode to be executed.

pub fn take_profiling_samples(&mut self) -> ProfilingSamples

pub fn finalize(self) -> WitnessMap<F>

Finalize the ACVM execution, returning the resulting WitnessMap.

fn status(&mut self, status: ACVMStatus<F>) -> ACVMStatus<F>

Updates the current status of the VM. Returns the given status.

pub fn get_status(&self) -> &ACVMStatus<F>

fn fail(&mut self, error: OpcodeResolutionError<F>) -> ACVMStatus<F>

Sets the VM status to ACVMStatus::Failure using the provided error. Returns the new status.

fn wait_for_foreign_call( &mut self, foreign_call: ForeignCallWaitInfo<F>, ) -> ACVMStatus<F>

Sets the status of the VM to RequiresForeignCall. Indicating that the VM is now waiting for a foreign call to be resolved.

pub fn get_pending_foreign_call(&self) -> Option<&ForeignCallWaitInfo<F>>

Return a reference to the arguments for the next pending foreign call, if one exists.

pub fn resolve_pending_foreign_call( &mut self, foreign_call_result: ForeignCallResult<F>, )

Resolves a foreign call’s result using a result calculated outside of the ACVM.

The ACVM can then be restarted to solve the remaining Brillig VM process as well as the remaining ACIR opcodes.

fn wait_for_acir_call( &mut self, acir_call: AcirCallWaitInfo<F>, ) -> ACVMStatus<F>

Sets the status of the VM to RequiresAcirCall Indicating that the VM is now waiting for an ACIR call to be resolved

pub fn resolve_pending_acir_call(&mut self, call_result: Vec<F>)

Resolves an ACIR call’s result (simply a list of fields) using a result calculated by a separate ACVM instance.

The current ACVM instance can then be restarted to solve the remaining ACIR opcodes.

pub fn solve(&mut self) -> ACVMStatus<F>

Executes the ACVM’s circuit until execution halts.

Execution can halt due to three reasons:

1. All opcodes have been executed successfully.
2. The circuit has been found to be unsatisfiable.
3. A Brillig foreign call has been encountered and must be resolved.

fn current_opcode(&self) -> &'a Opcode<F>

pub fn solve_opcode(&mut self) -> ACVMStatus<F>

Executes a single opcode using the dedicated solver.

Foreign or ACIR Calls are deferred to the caller, which will either instantiate a new ACVM to execute the called ACIR function or a custom implementation to execute the foreign call. Then it will resume execution of the current ACVM with the results of the call.

fn handle_opcode_resolution( &mut self, resolution: Result<(), OpcodeResolutionError<F>>, ) -> ACVMStatus<F>

Returns the status of the ACVM If the status is an error, it converts the error into OpcodeResolutionError

fn extract_assertion_payload( &self, location: OpcodeLocation, ) -> Option<ResolvedAssertionPayload<F>>

fn solve_brillig_call_opcode( &mut self, id: &BrilligFunctionId, inputs: &'a [BrilligInputs<F>], outputs: &[BrilligOutputs], predicate: &Option<Expression<F>>, ) -> Result<Option<ForeignCallWaitInfo<F>>, OpcodeResolutionError<F>>

Solves a Brillig Call opcode, which represents a call to an unconstrained function. It first handles the predicate and returns zero values if the predicate is false. Then it executes (or resumes execution) the Brillig function using a Brillig VM.

pub fn step_into_brillig(&mut self) -> StepResult<'a, F, B>

pub fn finish_brillig_with_solver( &mut self, solver: BrilligSolver<'a, F, B>, ) -> ACVMStatus<F>

pub fn solve_call_opcode( &mut self, id: &AcirFunctionId, inputs: &[Witness], outputs: &[Witness], predicate: &Option<Expression<F>>, ) -> Result<Option<AcirCallWaitInfo<F>>, OpcodeResolutionError<F>>

Defer execution of the ACIR call opcode to the caller, or finalize the execution.

1. It first handles the predicate and return zero values if the predicate is false.
2. If the results of the execution are not available, it issues a ‘AcirCallWaitInfo’ to notify the caller that it (the caller) needs to execute the ACIR function.
3. If the results are available, it updates the witness map and indicates that the opcode is solved.