Execute simple_package on native

Author: cptartur

Cargo.lock

@@ -32,6 +32,7 @@ license-file = "LICENSE"
 blockifier = { git = "https://github.com/cptartur/sequencer.git", branch = "main-v0.14.0-fork", features = ["testing", "tracing", "cairo_native"] }
 bigdecimal = "0.4.8"
 starknet_api = { git = "https://github.com/cptartur/sequencer.git", branch = "main-v0.14.0-fork" }
+cairo-native = { git = "https://github.com/lambdaclass/cairo_native.git", rev = "d7f8352657a4c1228b227807b90aea10f97f746d" }
 cairo-lang-casm = { version = "2.12.0", features = ["serde"] }
 cairo-lang-sierra = "2.12.0"
 cairo-lang-utils = "2.12.0"

Cargo.toml

@@ -44,6 +44,7 @@ shared.workspace = true
 rand.workspace = true
 foundry-ui = { path = "../foundry-ui" }
 scarb-oracle-hint-service.workspace =  true
+cairo-native.workspace = true
 
 [dev-dependencies]
 ctor.workspace = true

crates/cheatnet/Cargo.toml

@@ -3,11 +3,12 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::rpc::{AddressOrClassHash, CallResult};
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::CheatnetState;
 use crate::runtime_extensions::common::{get_relocated_vm_trace, get_syscalls_gas_consumed, sum_syscall_usage};
+use crate::runtime_extensions::forge_runtime_extension::{get_nested_calls_syscalls_sierra_gas, get_nested_calls_syscalls_vm_resources};
 use crate::state::CheatStatus;
 use blockifier::execution::call_info::{CallExecution, Retdata, StorageAccessTracker};
-use crate::runtime_extensions::forge_runtime_extension::{get_nested_calls_syscalls_sierra_gas, get_nested_calls_syscalls_vm_resources};
 use blockifier::execution::contract_class::{RunnableCompiledClass, TrackedResource};
 
+use crate::runtime_extensions::native::execution::execute_entry_point_call_native;
 use blockifier::execution::entry_point::{EntryPointRevertInfo, ExecutableCallEntryPoint};
 use blockifier::execution::stack_trace::{
     Cairo1RevertHeader, extract_trailing_cairo1_revert_trace,
@@ -174,7 +175,27 @@ pub fn execute_call_entry_point(
             cheatnet_state,
             context,
         ),
-        RunnableCompiledClass::V1Native(_) => todo!(),
+        RunnableCompiledClass::V1Native(native_compiled_class_v1) => {
+            // if context.tracked_resource_stack.last() == Some(&TrackedResource::CairoSteps) {
+            //     // We cannot run native with cairo steps as the tracked resources (it's a vm
+            //     // resouorce).
+            //     panic!("We want to test execution of native entry only");
+            //     // execute_entry_point_call_cairo1(
+            //     //     call,
+            //     //     compiled_class.casm(),
+            //     //     state,
+            //     //     context,
+            //     // )
+            // } else {
+            println!("Executing native entry point");
+            execute_entry_point_call_native(
+                entry_point.clone(),
+                native_compiled_class_v1,
+                state,
+                cheatnet_state,
+                context,
+            )
+        } // }
     };
     context
         .tracked_resource_stack

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/entry_point.rs

@@ -5,10 +5,14 @@ use crate::runtime_extensions::forge_runtime_extension::{
 };
 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 starknet::core::types::contract::SierraClass;
+use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::{ClassHash, CompiledClassHash};
 
 #[derive(CairoSerialize)]
@@ -27,12 +31,41 @@ 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 = RunnableCompiledClass::V1(contract_class);
+    let contract_class = NativeCompiledClassV1::new(executor, contract_class);
+    let contract_class = RunnableCompiledClass::V1Native(contract_class);
 
     let class_hash = *contracts_data
         .get_class_hash(contract_name)

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

@@ -4,3 +4,4 @@ pub mod common;
 pub mod deprecated_cheatable_starknet_extension;
 pub mod forge_config_extension;
 pub mod forge_runtime_extension;
+mod native;

crates/cheatnet/src/runtime_extensions/mod.rs

@@ -0,0 +1,28 @@
+use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::entry_point::{
+    CallInfoWithExecutionData, ContractClassEntryPointExecutionResult,
+};
+use crate::state::CheatnetState;
+use blockifier::execution::entry_point::{EntryPointExecutionContext, ExecutableCallEntryPoint};
+use blockifier::execution::native::contract_class::NativeCompiledClassV1;
+use blockifier::execution::native::entry_point_execution::execute_entry_point_call;
+use blockifier::state::state_api::State;
+use std::default::Default;
+
+pub(crate) fn execute_entry_point_call_native(
+    call: ExecutableCallEntryPoint,
+    native_compiled_class_v1: NativeCompiledClassV1,
+    state: &mut dyn State,
+    cheatnet_state: &mut CheatnetState, // Added parameter
+    context: &mut EntryPointExecutionContext,
+) -> ContractClassEntryPointExecutionResult {
+    // TODO error handling
+    let call_info = execute_entry_point_call(call, native_compiled_class_v1, state, context)
+        .expect("Native execution failed");
+
+    Ok(CallInfoWithExecutionData {
+        call_info,
+        syscall_usage_vm_resources: Default::default(),
+        syscall_usage_sierra_gas: Default::default(),
+        vm_trace: None,
+    })
+}

crates/cheatnet/src/runtime_extensions/native/execution.rs

@@ -0,0 +1 @@
+pub mod execution;