Running config run through blockifier

commit-id:4f165000

Author: cptartur

crates/forge-runner/src/package_tests.rs

@@ -1,3 +1,5 @@
+use crate::running::hints_to_params;
+use anyhow::Result;
 use cairo_lang_sierra::extensions::NamedType;
 use cairo_lang_sierra::extensions::bitwise::BitwiseType;
 use cairo_lang_sierra::extensions::circuit::{AddModType, MulModType};
@@ -8,8 +10,13 @@ use cairo_lang_sierra::extensions::range_check::{RangeCheck96Type, RangeCheckTyp
 use cairo_lang_sierra::extensions::segment_arena::SegmentArenaType;
 use cairo_lang_sierra::ids::GenericTypeId;
 use cairo_lang_sierra::program::ProgramArtifact;
+use cairo_vm::serde::deserialize_program::ReferenceManager;
 use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::types::program::Program;
+use cairo_vm::types::relocatable::MaybeRelocatable;
 use camino::Utf8PathBuf;
+use starknet_types_core::felt::Felt;
+use std::collections::HashMap;
 use std::sync::Arc;
 use universal_sierra_compiler_api::AssembledProgramWithDebugInfo;
 
@@ -57,6 +64,36 @@ impl TestDetails {
         }
         builtins
     }
+
+    pub fn try_into_program(
+        &self,
+        casm_program: &AssembledProgramWithDebugInfo,
+    ) -> Result<Program> {
+        let builtins = self.builtins();
+
+        let assembled_program = &casm_program.assembled_cairo_program;
+        let hints_dict = hints_to_params(assembled_program);
+        let data: Vec<MaybeRelocatable> = assembled_program
+            .bytecode
+            .iter()
+            .map(Felt::from)
+            .map(MaybeRelocatable::from)
+            .collect();
+
+        Program::new(
+            builtins.clone(),
+            data,
+            Some(0),
+            hints_dict,
+            ReferenceManager {
+                references: Vec::new(),
+            },
+            HashMap::new(),
+            vec![],
+            None,
+        )
+        .map_err(std::convert::Into::into)
+    }
 }
 
 #[derive(Debug, Clone)]

crates/forge-runner/src/package_tests/with_config_resolved.rs

@@ -1,16 +1,11 @@
 use super::{TestCase, TestTarget};
 use crate::expected_result::ExpectedTestResult;
-use crate::running::hints_to_params;
 use anyhow::Result;
-use cairo_vm::serde::deserialize_program::ReferenceManager;
 use cairo_vm::types::program::Program;
-use cairo_vm::types::relocatable::MaybeRelocatable;
 use cheatnet::runtime_extensions::forge_config_extension::config::{
     RawAvailableGasConfig, RawFuzzerConfig,
 };
 use starknet_api::block::BlockNumber;
-use starknet_types_core::felt::Felt;
-use std::collections::HashMap;
 use universal_sierra_compiler_api::AssembledProgramWithDebugInfo;
 use url::Url;
 
@@ -23,30 +18,7 @@ impl TestCaseWithResolvedConfig {
         &self,
         casm_program: &AssembledProgramWithDebugInfo,
     ) -> Result<Program> {
-        let builtins = self.test_details.builtins();
-
-        let assembled_program = &casm_program.assembled_cairo_program;
-        let hints_dict = hints_to_params(assembled_program);
-        let data: Vec<MaybeRelocatable> = assembled_program
-            .bytecode
-            .iter()
-            .map(Felt::from)
-            .map(MaybeRelocatable::from)
-            .collect();
-
-        Program::new(
-            builtins.clone(),
-            data,
-            Some(0),
-            hints_dict,
-            ReferenceManager {
-                references: Vec::new(),
-            },
-            HashMap::new(),
-            vec![],
-            None,
-        )
-        .map_err(std::convert::Into::into)
+        self.test_details.try_into_program(casm_program)
     }
 }
 

crates/forge-runner/src/running.rs

@@ -52,18 +52,16 @@ use tokio::sync::mpsc::Sender;
 use tokio::task::JoinHandle;
 use universal_sierra_compiler_api::AssembledProgramWithDebugInfo;
 
-mod casm;
 pub mod config_run;
 mod copied_code;
-mod entry_code;
 mod hints;
 mod syscall_handler;
 pub mod with_config;
 
+use crate::package_tests::TestDetails;
 use crate::running::copied_code::{
     finalize_execution, prepare_call_arguments, prepare_program_extra_data, run_entry_point,
 };
-use crate::running::syscall_handler::build_syscall_handler;
 pub use hints::hints_to_params;
 pub use syscall_handler::has_segment_arena;
 pub use syscall_handler::syscall_handler_offset;
@@ -242,11 +240,11 @@ fn entry_point_initial_budget(forge_runtime: &ForgeRuntime) -> u64 {
 }
 
 fn build_test_call_and_entry_point(
-    case: &TestCaseWithResolvedConfig,
+    test_details: &TestDetails,
     casm_program: &AssembledProgramWithDebugInfo,
     program: &Program,
 ) -> (ExecutableCallEntryPoint, EntryPointV1) {
-    let sierra_instruction_idx = case.test_details.sierra_entry_point_statement_idx;
+    let sierra_instruction_idx = test_details.sierra_entry_point_statement_idx;
     let casm_entry_point_offset = casm_program.debug_info[sierra_instruction_idx].0;
 
     let call = build_test_entry_point();
@@ -266,7 +264,8 @@ pub fn run_test_case(
     fuzzer_rng: Option<Arc<Mutex<StdRng>>>,
 ) -> Result<RunResult> {
     let program = case.try_into_program(casm_program)?;
-    let (call, entry_point) = build_test_call_and_entry_point(case, casm_program, &program);
+    let (call, entry_point) =
+        build_test_call_and_entry_point(&case.test_details, casm_program, &program);
 
     let mut state_reader = ExtendedStateReader {
         dict_state_reader: cheatnet_constants::build_testing_state(),

crates/forge-runner/src/running/casm.rs

@@ -1,11 +1,9 @@
 use super::{
-    casm::{get_assembled_program, run_assembled_program},
-    entry_code::create_entry_code,
-    hints::{hints_by_representation, hints_to_params},
-};
-use crate::{
-    forge_config::ForgeTrackedResource, package_tests::TestDetails, running::build_syscall_handler,
+    VmExecutionContext, build_test_call_and_entry_point, hints::hints_by_representation,
+    initialize_execution_context,
 };
+use crate::running::copied_code::{finalize_execution, prepare_call_arguments, run_entry_point};
+use crate::{forge_config::ForgeTrackedResource, package_tests::TestDetails};
 use anyhow::Result;
 use blockifier::execution::contract_class::TrackedResource;
 use blockifier::state::{cached_state::CachedState, state_api::StateReader};
@@ -20,6 +18,7 @@ use starknet_api::block::{
 use starknet_types_core::felt::Felt;
 use std::default::Default;
 use universal_sierra_compiler_api::AssembledProgramWithDebugInfo;
+
 struct PhantomStateReader;
 
 impl StateReader for PhantomStateReader {
@@ -63,11 +62,14 @@ pub fn run_config_pass(
     casm_program: &AssembledProgramWithDebugInfo,
     tracked_resource: &ForgeTrackedResource,
 ) -> Result<RawForgeConfig> {
+    let program = test_details.try_into_program(casm_program)?;
+    let (call, entry_point) = build_test_call_and_entry_point(test_details, casm_program, &program);
+
     let mut cached_state = CachedState::new(PhantomStateReader);
     let gas_price_vector = GasPriceVector {
-        l1_gas_price: NonzeroGasPrice::new(GasPrice(2)).unwrap(),
-        l1_data_gas_price: NonzeroGasPrice::new(GasPrice(2)).unwrap(),
-        l2_gas_price: NonzeroGasPrice::new(GasPrice(2)).unwrap(),
+        l1_gas_price: NonzeroGasPrice::new(GasPrice(2))?,
+        l1_data_gas_price: NonzeroGasPrice::new(GasPrice(2))?,
+        l2_gas_price: NonzeroGasPrice::new(GasPrice(2))?,
     };
 
     let block_info = BlockInfo {
@@ -80,22 +82,21 @@ pub fn run_config_pass(
         sequencer_address: 0_u8.into(),
         use_kzg_da: true,
     };
-    let (entry_code, builtins) = create_entry_code(test_details, casm_program);
-
-    let assembled_program = get_assembled_program(casm_program, entry_code);
-
-    let string_to_hint = hints_by_representation(&assembled_program);
-    let hints_dict = hints_to_params(&assembled_program);
-
     let mut context = build_context(&block_info, None, &TrackedResource::from(tracked_resource));
 
-    let syscall_handler = build_syscall_handler(
+    let hints = hints_by_representation(&casm_program.assembled_cairo_program);
+    let VmExecutionContext {
+        mut runner,
+        syscall_handler,
+        initial_syscall_ptr,
+        program_extra_data_length,
+    } = initialize_execution_context(
+        call.clone(),
+        &hints,
+        &program,
         &mut cached_state,
-        &string_to_hint,
         &mut context,
-        &test_details.parameter_types,
-        builtins.len(),
-    );
+    )?;
 
     let mut config = RawForgeConfig::default();
 
@@ -115,11 +116,51 @@ pub fn run_config_pass(
         },
     };
 
-    run_assembled_program(
-        &assembled_program,
-        builtins,
-        hints_dict,
+    let tracked_resource = TrackedResource::from(tracked_resource);
+    let entry_point_initial_budget = forge_config_runtime
+        .extended_runtime
+        .hint_handler
+        .base
+        .context
+        .gas_costs()
+        .base
+        .entry_point_initial_budget;
+    let args = prepare_call_arguments(
+        &forge_config_runtime
+            .extended_runtime
+            .hint_handler
+            .base
+            .call
+            .clone()
+            .into(),
+        &mut runner,
+        initial_syscall_ptr,
+        &mut forge_config_runtime
+            .extended_runtime
+            .hint_handler
+            .read_only_segments,
+        &entry_point,
+        entry_point_initial_budget,
+    )?;
+    let n_total_args = args.len();
+
+    let bytecode_length = program.data_len();
+    let program_segment_size = bytecode_length + program_extra_data_length;
+
+    run_entry_point(
+        &mut runner,
         &mut forge_config_runtime,
+        entry_point,
+        args,
+        program_segment_size,
+    )?;
+
+    finalize_execution(
+        &mut runner,
+        &mut forge_config_runtime.extended_runtime.hint_handler,
+        n_total_args,
+        program_extra_data_length,
+        tracked_resource,
     )?;
 
     Ok(config)