Bump blockifier, change deps, make compile (#3713)

**Stack**:
- #3711
- #3710
- #3709
- #3713 ⬅


⚠️ *Part of a stack created by [spr](https://github.com/ejoffe/spr). Do
not merge manually using the UI - doing so may have unexpected results.*

---------

Co-authored-by: Artur Michalek <[email protected]>

Author: ksew1

Cargo.lock

@@ -17,6 +17,7 @@ members = [
     "crates/debugging",
     "crates/testing/packages_validation",
     "crates/foundry-ui",
+    "crates/native-api",
 ]
 
 exclude = ["crates/snforge-scarb-plugin", "crates/snforge-scarb-plugin-deprecated"]

Cargo.toml

@@ -7,12 +7,10 @@ use anyhow::{Context, Result};
 use blockifier::execution::contract_class::{CompiledClassV1, RunnableCompiledClass};
 use blockifier::execution::native::contract_class::NativeCompiledClassV1;
 use blockifier::state::{errors::StateError, state_api::State};
-use cairo_lang_starknet_classes::contract_class::ContractClass;
-use cairo_native::executor::AotContractExecutor;
 use conversions::IntoConv;
 use conversions::serde::serialize::CairoSerialize;
+use scarb_api::StarknetContractArtifacts;
 use starknet::core::types::contract::SierraClass;
-use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::{ClassHash, CompiledClassHash};
 
 #[derive(CairoSerialize)]
@@ -31,41 +29,7 @@ pub fn declare(
         .with_context(|| format!("Failed to get contract artifact for name = {contract_name}."))
         .map_err(EnhancedHintError::from)?;
 
-    let sierra_contract_class: ContractClass =
-        serde_json::from_str(&contract_artifact.sierra).unwrap();
-
-    let sierra_program = sierra_contract_class
-        .extract_sierra_program()
-        .expect("Cannot extract sierra program from sierra contract class");
-
-    let sierra_version_values = sierra_contract_class
-        .sierra_program
-        .iter()
-        .take(3)
-        .map(|x| x.value.clone())
-        .collect::<Vec<_>>();
-
-    let sierra_version = SierraVersion::extract_from_program(&sierra_version_values)
-        .expect("Cannot extract sierra version from sierra program");
-
-    let executor = AotContractExecutor::new(
-        &sierra_program,
-        &sierra_contract_class.entry_points_by_type,
-        sierra_version.clone().into(),
-        cairo_native::OptLevel::Default,
-        // `stats` - Passing a [cairo_native::statistics::Statistics] object enables collecting
-        // compilation statistics.
-        None,
-    )
-    .expect("Cannot compile sierra into native");
-
-    let contract_class = CompiledClassV1::try_from_json_string(
-        &contract_artifact.casm,
-        get_current_sierra_version(),
-    )
-    .expect("Failed to read contract class from json");
-    let contract_class = NativeCompiledClassV1::new(executor, contract_class);
-    let contract_class = RunnableCompiledClass::V1Native(contract_class);
+    let contract_class = get_contract_class(contract_artifact);
 
     let class_hash = *contracts_data
         .get_class_hash(contract_name)
@@ -101,3 +65,19 @@ pub fn declare(
 pub fn get_class_hash(sierra_class: &SierraClass) -> Result<ClassHash> {
     Ok(sierra_class.class_hash()?.into_())
 }
+
+fn get_contract_class(contract_artifact: &StarknetContractArtifacts) -> RunnableCompiledClass {
+    let contract_class = CompiledClassV1::try_from_json_string(
+        &contract_artifact.casm,
+        get_current_sierra_version(),
+    )
+    .expect("Failed to read contract class from json");
+
+    match &contract_artifact.executor {
+        None => RunnableCompiledClass::V1(contract_class),
+        Some(executor) => RunnableCompiledClass::V1Native(NativeCompiledClassV1::new(
+            executor.clone(),
+            contract_class,
+        )),
+    }
+}

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/cheatcodes/declare.rs

@@ -29,7 +29,8 @@ use runtime::starknet::constants::TEST_ADDRESS;
 use runtime::starknet::context::build_context;
 use scarb_api::metadata::MetadataCommandExt;
 use scarb_api::{
-    ScarbCommand, get_contracts_artifacts_and_source_sierra_paths, target_dir_for_workspace,
+    CompilationOpts, ScarbCommand, get_contracts_artifacts_and_source_sierra_paths,
+    target_dir_for_workspace,
 };
 use starknet::core::utils::get_selector_from_name;
 use starknet_api::contract_class::EntryPointType;
@@ -85,8 +86,13 @@ pub fn get_contracts() -> ContractsData {
     let package = scarb_metadata.packages.first().unwrap();
 
     let ui = UI::default();
-    let contracts =
-        get_contracts_artifacts_and_source_sierra_paths(&target_dir, package, false, &ui).unwrap();
+    let contracts = get_contracts_artifacts_and_source_sierra_paths(
+        &target_dir,
+        package,
+        &ui,
+        CompilationOpts::default(),
+    )
+    .unwrap();
     ContractsData::try_from(contracts).unwrap()
 }
 

crates/cheatnet/tests/common/mod.rs

@@ -142,6 +142,12 @@ pub struct TestArgs {
     #[command(flatten)]
     trace_args: TraceArgs,
 
+    /// Run contracts on `cairo-native` instead of the default `cairo-vm`.
+    ///
+    /// Note: Only contracts execution through native is supported, test code itself will still run on `cairo-vm`.
+    #[arg(long)]
+    run_native: bool,
+
     /// Use exact matches for `test_filter`
     #[arg(short, long)]
     exact: bool,
@@ -169,7 +175,7 @@ pub struct TestArgs {
     include_ignored: bool,
 
     /// Display more detailed info about used resources
-    #[arg(long)]
+    #[arg(long, conflicts_with = "run_native")]
     detailed_resources: bool,
 
     /// Control when colored output is used
@@ -181,15 +187,15 @@ pub struct TestArgs {
     rerun_failed: bool,
 
     /// Save execution traces of all test which have passed and are not fuzz tests
-    #[arg(long)]
+    #[arg(long, conflicts_with = "run_native")]
     save_trace_data: bool,
 
     /// Build profiles of all tests which have passed and are not fuzz tests using the cairo-profiler
-    #[arg(long, conflicts_with = "coverage")]
+    #[arg(long, conflicts_with_all = ["run_native", "coverage"])]
     build_profile: bool,
 
     /// Generate a coverage report for the executed tests which have passed and are not fuzz tests using the cairo-coverage
-    #[arg(long, conflicts_with = "build_profile")]
+    #[arg(long, conflicts_with_all = ["run_native", "build_profile"])]
     coverage: bool,
 
     /// Number of maximum steps during a single test. For fuzz tests this value is applied to each subtest separately.

crates/forge/src/lib.rs

@@ -1,16 +1,30 @@
+use crate::TestArgs;
 use crate::profile_validation::{check_cairo_profile_entries, get_manifest};
 use anyhow::ensure;
 use indoc::formatdoc;
 use scarb_metadata::Metadata;
 use semver::Version;
 
-/// Checks if backtrace can be generated based on scarb version and profile settings extracted from the provided [`Metadata`].
-pub fn check_backtrace_compatibility(scarb_metadata: &Metadata) -> anyhow::Result<()> {
+/// Checks if backtrace can be generated based on scarb version, profile settings extracted from
+/// the provided [`Metadata`] and if native execution is disabled in the provided [`TestArgs`].
+pub fn check_backtrace_compatibility(
+    test_args: &TestArgs,
+    scarb_metadata: &Metadata,
+) -> anyhow::Result<()> {
+    check_if_native_disabled(test_args)?;
     check_scarb_version(scarb_metadata)?;
     check_profile(scarb_metadata)?;
     Ok(())
 }
 
+/// Checks if native execution is disabled in the provided [`TestArgs`].
+fn check_if_native_disabled(test_args: &TestArgs) -> anyhow::Result<()> {
+    ensure!(
+        !test_args.run_native,
+        "Backtrace generation is not supported with `cairo-native` execution",
+    );
+    Ok(())
+}
 /// Checks if the scarb version from the provided [`Metadata`] is greater than or equal to the minimal required version.
 fn check_scarb_version(scarb_metadata: &Metadata) -> anyhow::Result<()> {
     const MINIMAL_SCARB_VERSION: Version = Version::new(2, 8, 0);

crates/forge/src/profile_validation/backtrace.rs

@@ -18,7 +18,7 @@ pub fn check_profile_compatibility(
         check_coverage_compatibility(scarb_metadata)?;
     }
     if is_backtrace_enabled() {
-        check_backtrace_compatibility(scarb_metadata)?;
+        check_backtrace_compatibility(test_args, scarb_metadata)?;
     }
     Ok(())
 }

crates/forge/src/profile_validation/mod.rs

@@ -31,7 +31,7 @@ use forge_runner::{
     test_target_summary::TestTargetSummary,
 };
 use foundry_ui::{UI, components::labeled::LabeledMessage};
-use scarb_api::get_contracts_artifacts_and_source_sierra_paths;
+use scarb_api::{CompilationOpts, get_contracts_artifacts_and_source_sierra_paths};
 use scarb_metadata::{Metadata, PackageMetadata};
 use std::sync::Arc;
 
@@ -82,11 +82,14 @@ impl RunForPackageArgs {
         let contracts = get_contracts_artifacts_and_source_sierra_paths(
             artifacts_dir,
             &package,
-            !should_compile_starknet_contract_target(
-                &scarb_metadata.app_version_info.version,
-                args.no_optimization,
-            ),
             ui,
+            CompilationOpts {
+                use_test_target_contracts: !should_compile_starknet_contract_target(
+                    &scarb_metadata.app_version_info.version,
+                    args.no_optimization,
+                ),
+                run_native: args.run_native,
+            },
         )?;
         let contracts_data = ContractsData::try_from(contracts)?;
 

crates/forge/src/run_tests/package.rs

@@ -17,8 +17,9 @@ use forge_runner::{
 use foundry_ui::UI;
 use indoc::formatdoc;
 use scarb_api::{
-    ScarbCommand, StarknetContractArtifacts, get_contracts_artifacts_and_source_sierra_paths,
-    metadata::MetadataCommandExt, target_dir_for_workspace,
+    CompilationOpts, ScarbCommand, StarknetContractArtifacts,
+    get_contracts_artifacts_and_source_sierra_paths, metadata::MetadataCommandExt,
+    target_dir_for_workspace,
 };
 use shared::command::CommandExt;
 use starknet_api::execution_resources::{GasAmount, GasVector};
@@ -104,12 +105,16 @@ impl Contract {
             .unwrap();
         let artifacts_dir = target_dir_for_workspace(&scarb_metadata).join("dev");
 
-        let contract =
-            get_contracts_artifacts_and_source_sierra_paths(&artifacts_dir, package, false, ui)
-                .unwrap()
-                .remove(&self.name)
-                .ok_or(anyhow!("there is no contract with name {}", self.name))?
-                .0;
+        let contract = get_contracts_artifacts_and_source_sierra_paths(
+            &artifacts_dir,
+            package,
+            ui,
+            CompilationOpts::default(),
+        )
+        .unwrap()
+        .remove(&self.name)
+        .ok_or(anyhow!("there is no contract with name {}", self.name))?
+        .0;
 
         Ok((contract.sierra, contract.casm))
     }
@@ -221,7 +226,11 @@ impl<'a> TestCase {
                 Ok((
                     name,
                     (
-                        StarknetContractArtifacts { sierra, casm },
+                        StarknetContractArtifacts {
+                            sierra,
+                            casm,
+                            executor: None,
+                        },
                         Utf8PathBuf::default(),
                     ),
                 ))

crates/forge/test_utils/src/runner.rs

@@ -23,6 +23,18 @@ fn test_backtrace_missing_env() {
     );
 }
 
+#[test]
+fn test_backtrace_native_execution() {
+    let temp = setup_package("backtrace_vm_error");
+
+    test_runner(&temp)
+        .arg("--run-native")
+        .env("SNFORGE_BACKTRACE", "1")
+        .assert()
+        .code(2)
+        .stdout_eq("[ERROR] Backtrace generation is not supported with `cairo-native` execution\n");
+}
+
 #[test]
 fn test_backtrace() {
     let temp = setup_package("backtrace_vm_error");