Struct cairo_vm::vm::runners::cairo_runner::CairoRunner

pub struct CairoRunner {
    pub vm: VirtualMachine,
    pub program_base: Option<Relocatable>,
    pub relocated_memory: Vec<Option<Felt252>>,
    pub exec_scopes: ExecutionScopes,
    pub relocated_trace: Option<Vec<RelocatedTraceEntry>>,
    /* private fields */
}

Fields

vm: VirtualMachine

program_base: Option<Relocatable>

relocated_memory: Vec<Option<Felt252>>

exec_scopes: ExecutionScopes

relocated_trace: Option<Vec<RelocatedTraceEntry>>

Implementations

impl CairoRunner

pub fn new_v2( program: &Program, layout: LayoutName, mode: RunnerMode, trace_enabled: bool, ) -> Result<CairoRunner, RunnerError>

pub fn new( program: &Program, layout: LayoutName, proof_mode: bool, trace_enabled: bool, ) -> Result<CairoRunner, RunnerError>

pub fn initialize( &mut self, allow_missing_builtins: bool, ) -> Result<Relocatable, RunnerError>

pub fn initialize_builtins( &mut self, allow_missing_builtins: bool, ) -> Result<(), RunnerError>

Creates the builtin runners according to the builtins used by the program and the selected layout When running in proof_mode, all builtins in the layout will be created, and only those in the program will be included When not running in proof_mode, only program builtins will be created and included Unless allow_missing_builtins is set to true, an error will be returned if a builtin is included in the program but not on the layout

pub fn initialize_program_builtins(&mut self) -> Result<(), RunnerError>

pub fn initialize_segments(&mut self, program_base: Option<Relocatable>)

Creates the necessary segments for the program, execution, and each builtin on the MemorySegmentManager and stores the first adress of each of this new segments as each owner’s base

pub fn initialize_function_entrypoint( &mut self, entrypoint: usize, stack: Vec<MaybeRelocatable>, return_fp: MaybeRelocatable, ) -> Result<Relocatable, RunnerError>

pub fn initialize_vm(&mut self) -> Result<(), RunnerError>

pub fn get_initial_fp(&self) -> Option<Relocatable>

pub fn get_hint_data( &self, references: &[HintReference], hint_executor: &mut dyn HintProcessor, ) -> Result<Vec<Box<dyn Any>>, VirtualMachineError>

Gets the data used by the HintProcessor to execute each hint

pub fn get_constants(&self) -> &HashMap<String, Felt252>

pub fn get_program_builtins(&self) -> &Vec<BuiltinName>

pub fn run_until_pc( &mut self, address: Relocatable, hint_processor: &mut dyn HintProcessor, ) -> Result<(), VirtualMachineError>

pub fn run_for_steps( &mut self, steps: usize, hint_processor: &mut dyn HintProcessor, ) -> Result<(), VirtualMachineError>

Execute an exact number of steps on the program from the actual position.

pub fn run_until_steps( &mut self, steps: usize, hint_processor: &mut dyn HintProcessor, ) -> Result<(), VirtualMachineError>

Execute steps until a number of steps since the start of the program is reached.

pub fn run_until_next_power_of_2( &mut self, hint_processor: &mut dyn HintProcessor, ) -> Result<(), VirtualMachineError>

Execute steps until the step counter reaches a power of two.

pub fn get_perm_range_check_limits(&self) -> Option<(isize, isize)>

pub fn check_range_check_usage(&self) -> Result<(), VirtualMachineError>

Checks that there are enough trace cells to fill the entire range check range.

pub fn get_memory_holes(&self) -> Result<usize, MemoryError>

Count the number of holes present in the segments.

pub fn check_diluted_check_usage(&self) -> Result<(), VirtualMachineError>

Check if there are enough trace cells to fill the entire diluted checks.

pub fn end_run( &mut self, disable_trace_padding: bool, disable_finalize_all: bool, hint_processor: &mut dyn HintProcessor, ) -> Result<(), VirtualMachineError>

pub fn relocate_trace( &mut self, relocation_table: &[usize], ) -> Result<(), TraceError>

Relocates the VM’s trace, turning relocatable registers to numbered ones

pub fn relocate(&mut self, relocate_mem: bool) -> Result<(), TraceError>

pub fn get_builtin_segments_info( &self, ) -> Result<Vec<(usize, usize)>, RunnerError>

pub fn get_builtin_segment_info_for_pie( &self, ) -> Result<HashMap<BuiltinName, SegmentInfo>, RunnerError>

pub fn get_execution_resources(&self) -> Result<ExecutionResources, RunnerError>

pub fn finalize_segments(&mut self) -> Result<(), RunnerError>

pub fn run_from_entrypoint( &mut self, entrypoint: usize, args: &[&CairoArg], verify_secure: bool, program_segment_size: Option<usize>, hint_processor: &mut dyn HintProcessor, ) -> Result<(), CairoRunError>

Runs a cairo program from a give entrypoint, indicated by its pc offset, with the given arguments. If verify_secure is set to true, verify_secure_runner will be called to run extra verifications. program_segment_size is only used by the verify_secure_runner function and will be ignored if verify_secure is set to false.

pub fn check_used_cells(&self) -> Result<(), VirtualMachineError>

pub fn check_memory_usage(&self) -> Result<(), VirtualMachineError>

pub fn initialize_function_runner_cairo_1( &mut self, program_builtins: &[BuiltinName], ) -> Result<(), RunnerError>

Intitializes the runner in order to run cairo 1 contract entrypoints Swaps the program’s builtins field with program_builtins Initializes program builtins & segments

pub fn initialize_function_runner(&mut self) -> Result<(), RunnerError>

Intitializes the runner in order to run cairo 0 contract entrypoints Initializes program builtins & segments

pub fn set_entrypoint( &mut self, new_entrypoint: Option<&str>, ) -> Result<(), ProgramError>

Overrides the previous entrypoint with a custom one, or “main” if none is specified.

pub fn read_return_values( &mut self, allow_missing_builtins: bool, ) -> Result<(), RunnerError>

pub fn get_builtins_final_stack( &mut self, stack_ptr: Relocatable, ) -> Result<Relocatable, RunnerError>

pub fn get_program(&self) -> &Program

Return CairoRunner.program

pub fn get_cairo_pie(&self) -> Result<CairoPie, RunnerError>

pub fn get_air_public_input(&self) -> Result<PublicInput<'_>, PublicInputError>

pub fn get_air_private_input(&self) -> AirPrivateInput

pub fn get_memory_segment_addresses( &self, ) -> Result<HashMap<&'static str, (usize, usize)>, VirtualMachineError>