Run tests through blockifier logic

commit-id:2777abe1

Author: cptartur

crates/cheatnet/src/state.rs

@@ -343,7 +343,8 @@ impl Default for CheatnetState {
             ClassHash(TryFromHexStr::try_from_hex_str(TEST_CONTRACT_CLASS_HASH).unwrap());
         let test_call = Rc::new(RefCell::new(CallTrace {
             entry_point: test_code_entry_point.into(),
-            run_with_call_header: true,
+            // TODO this field could be removed entirely
+            run_with_call_header: false,
             ..CallTrace::default_successful_call()
         }));
         Self {

crates/forge-runner/src/package_tests.rs

@@ -1,5 +1,14 @@
+use cairo_lang_sierra::extensions::NamedType;
+use cairo_lang_sierra::extensions::bitwise::BitwiseType;
+use cairo_lang_sierra::extensions::circuit::{AddModType, MulModType};
+use cairo_lang_sierra::extensions::ec::EcOpType;
+use cairo_lang_sierra::extensions::pedersen::PedersenType;
+use cairo_lang_sierra::extensions::poseidon::PoseidonType;
+use cairo_lang_sierra::extensions::range_check::{RangeCheck96Type, RangeCheckType};
+use cairo_lang_sierra::extensions::segment_arena::SegmentArenaType;
 use cairo_lang_sierra::ids::GenericTypeId;
 use cairo_lang_sierra::program::ProgramArtifact;
+use cairo_vm::types::builtin_name::BuiltinName;
 use camino::Utf8PathBuf;
 use std::sync::Arc;
 use universal_sierra_compiler_api::AssembledProgramWithDebugInfo;
@@ -8,6 +17,20 @@ pub mod raw;
 pub mod with_config;
 pub mod with_config_resolved;
 
+// If modifying this, make sure that the order of builtins matches that from
+// `#[implicit_precedence(...)` in generated test code.
+const BUILTIN_ORDER: [(BuiltinName, GenericTypeId); 9] = [
+    (BuiltinName::pedersen, PedersenType::ID),
+    (BuiltinName::range_check, RangeCheckType::ID),
+    (BuiltinName::bitwise, BitwiseType::ID),
+    (BuiltinName::ec_op, EcOpType::ID),
+    (BuiltinName::poseidon, PoseidonType::ID),
+    (BuiltinName::segment_arena, SegmentArenaType::ID),
+    (BuiltinName::range_check96, RangeCheck96Type::ID),
+    (BuiltinName::add_mod, AddModType::ID),
+    (BuiltinName::mul_mod, MulModType::ID),
+];
+
 #[derive(Debug, PartialEq, Clone, Copy, Hash, Eq)]
 pub enum TestTargetLocation {
     /// Main crate in a package
@@ -23,6 +46,19 @@ pub struct TestDetails {
     pub return_types: Vec<(GenericTypeId, i16)>,
 }
 
+impl TestDetails {
+    #[must_use]
+    pub fn builtins(&self) -> Vec<BuiltinName> {
+        let mut builtins = vec![];
+        for (builtin_name, builtin_ty) in BUILTIN_ORDER {
+            if self.parameter_types.iter().any(|(ty, _)| ty == &builtin_ty) {
+                builtins.push(builtin_name);
+            }
+        }
+        builtins
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TestTarget<C> {
     pub tests_location: TestTargetLocation,

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

@@ -1,15 +1,55 @@
 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;
 
 pub type TestTargetWithResolvedConfig = TestTarget<TestCaseResolvedConfig>;
 
 pub type TestCaseWithResolvedConfig = TestCase<TestCaseResolvedConfig>;
 
+impl TestCaseWithResolvedConfig {
+    pub fn try_into_program(
+        &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)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct ResolvedForkConfig {
     pub url: Url,