blockifier,apollo_compile_to_native: adopt cairo_native::ContractExecutor + libfunc profiling

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: avi-starkware

Cargo.lock

@@ -260,7 +260,11 @@ cairo-lang-sierra = "2.19.0-rc.3"
 cairo-lang-sierra-to-casm = "2.19.0-rc.3"
 cairo-lang-starknet-classes = "2.19.0-rc.3"
 cairo-lang-utils = "2.19.0-rc.3"
-cairo-native = "0.9.0-rc.7"
+# TEMP: git dep pinned to the tip of the unreleased PR stack
+# (starkware-libs/cairo_native#1610 → #1611 → #1612 → #1613) containing
+# `ContractExecutor`, `EmuContractInfo`, `AotWithProgram`, and `run_with_profile`.
+# Switch back to a crates.io version once those land in a published cairo-native release.
+cairo-native = { git = "https://github.com/starkware-libs/cairo_native.git", rev = "7107710f05801b63f3f40d863dd8ed38680cc6f6" }
 cairo-program-runner-lib = "1.1.0"
 cairo-vm = "3.2.0"
 camelpaste = "0.1.0"

Cargo.toml

@@ -9,6 +9,12 @@ description = "A utility crate for compiling Sierra code into Cairo native."
 [lints]
 workspace = true
 
+[features]
+# Enables `SierraToNativeCompiler::compile_with_program`, which returns the
+# AOT executor paired with the Sierra program required by cairo-native's
+# libfunc profiler.
+with-libfunc-profiling = ["cairo-native/with-libfunc-profiling"]
+
 [dependencies]
 apollo_compilation_utils.workspace = true
 apollo_compile_to_native_types.workspace = true

crates/apollo_compile_to_native/Cargo.toml

@@ -1,4 +1,6 @@
 use std::path::PathBuf;
+#[cfg(feature = "with-libfunc-profiling")]
+use std::sync::Arc;
 
 use apollo_compilation_utils::build_utils::verify_compiler_binary;
 use apollo_compilation_utils::compiler_utils::compile_with_args;
@@ -8,6 +10,8 @@ use apollo_compilation_utils::resource_limits::ResourceLimits;
 use apollo_compile_to_native_types::SierraCompilationConfig;
 use cairo_lang_starknet_classes::contract_class::ContractClass;
 use cairo_native::executor::AotContractExecutor;
+#[cfg(feature = "with-libfunc-profiling")]
+use cairo_native::executor::AotWithProgram;
 use tempfile::NamedTempFile;
 
 use crate::constants::{CAIRO_NATIVE_BINARY_NAME, REQUIRED_CAIRO_NATIVE_VERSION};
@@ -59,4 +63,25 @@ impl SierraToNativeCompiler {
             .map_err(|e| CompilationUtilError::CompilationError(e.to_string()))?
             .unwrap())
     }
+
+    /// Like [`Self::compile`], but also returns the Sierra program so cairo-native's
+    /// libfunc profiler can resolve runtime libfunc IDs back to declarations. The
+    /// program is extracted from `contract_class` before compilation so the two are
+    /// guaranteed to correspond.
+    #[cfg(feature = "with-libfunc-profiling")]
+    pub fn compile_with_program(
+        &self,
+        contract_class: ContractClass,
+    ) -> Result<AotWithProgram, CompilationUtilError> {
+        let program = contract_class
+            .extract_sierra_program(false)
+            .map(|extracted| Arc::new(extracted.program))
+            .map_err(|err| {
+                CompilationUtilError::UnexpectedError(format!(
+                    "Failed to extract Sierra program for profiling: {err}"
+                ))
+            })?;
+        let executor = self.compile(contract_class)?;
+        Ok(AotWithProgram { executor, program })
+    }
 }

crates/apollo_compile_to_native/src/compiler.rs

@@ -23,6 +23,9 @@ node_api = []
 only-native = ["cairo_native"]
 os_input = []
 reexecution = ["transaction_serde"]
+# Enables the sierra-emu execution path of `cairo_native::ContractExecutor`. Pulls in
+# cairo-native's `sierra-emu` feature which compiles `SierraEmuSyscallBridge`.
+sierra-emu = ["cairo-native/sierra-emu", "cairo_native"]
 testing = [
   "blockifier_test_utils",
   "expect-test",
@@ -33,6 +36,15 @@ testing = [
 ]
 tracing = []
 transaction_serde = []
+# Enables libfunc-level profiling for native execution. Pulls in cairo-native's
+# `with-libfunc-profiling` so `ContractExecutor::run_with_profile` is available,
+# and apollo_compile_to_native's matching feature so `SierraToNativeCompiler` can
+# pair the compiled executor with its Sierra program in one call.
+with-libfunc-profiling = [
+  "apollo_compile_to_native/with-libfunc-profiling",
+  "cairo-native/with-libfunc-profiling",
+  "cairo_native",
+]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

crates/blockifier/Cargo.toml

@@ -1,5 +1,8 @@
 pub mod contract_class;
 pub mod entry_point_execution;
+#[cfg(feature = "with-libfunc-profiling")]
+pub mod profiling;
+mod run_dispatch;
 pub mod syscall_handler;
 pub mod utils;
 

crates/blockifier/src/execution/native.rs

@@ -2,7 +2,11 @@ use std::borrow::Cow;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use cairo_native::executor::AotContractExecutor;
+#[cfg(feature = "with-libfunc-profiling")]
+use cairo_native::executor::AotWithProgram;
+#[cfg(feature = "sierra-emu")]
+use cairo_native::executor::EmuContractInfo;
+use cairo_native::executor::{AotContractExecutor, ContractExecutor};
 use starknet_api::contract_class::compiled_class_hash::HashableCompiledClass;
 use starknet_api::core::EntryPointSelector;
 use starknet_types_core::felt::Felt;
@@ -30,7 +34,28 @@ impl NativeCompiledClassV1 {
     /// executor must be derived from sierra_program which in turn must be derived from
     /// sierra_contract_class.
     pub fn new(executor: AotContractExecutor, casm: CompiledClassV1) -> NativeCompiledClassV1 {
-        let contract = NativeCompiledClassV1Inner::new(executor, casm);
+        let contract = NativeCompiledClassV1Inner::new(executor.into(), casm);
+
+        Self(Arc::new(contract))
+    }
+
+    /// Initialize a compiled class backed by the sierra-emu interpreter instead of the AOT
+    /// executor. Used by benchmarking / replay tooling that wants to execute through the emu
+    /// VM while reusing the rest of the blockifier pipeline.
+    #[cfg(feature = "sierra-emu")]
+    pub fn new_from_emu(info: EmuContractInfo, casm: CompiledClassV1) -> NativeCompiledClassV1 {
+        let contract = NativeCompiledClassV1Inner::new(info.into(), casm);
+
+        Self(Arc::new(contract))
+    }
+
+    /// Like [`Self::new`], but also stores the Sierra `Program` (via the cairo-native
+    /// [`AotWithProgram`] pairing) so [`cairo_native::ContractExecutor::run_with_profile`]
+    /// can resolve libfunc samples. Only callable when the `with-libfunc-profiling`
+    /// feature is enabled.
+    #[cfg(feature = "with-libfunc-profiling")]
+    pub fn new_with_program(info: AotWithProgram, casm: CompiledClassV1) -> NativeCompiledClassV1 {
+        let contract = NativeCompiledClassV1Inner::new(info.into(), casm);
 
         Self(Arc::new(contract))
     }
@@ -71,12 +96,12 @@ impl HashableCompiledClass<EntryPointV1, NestedFeltCounts> for NativeCompiledCla
 
 #[derive(Debug)]
 pub struct NativeCompiledClassV1Inner {
-    pub executor: AotContractExecutor,
+    pub executor: ContractExecutor,
     casm: CompiledClassV1,
 }
 
 impl NativeCompiledClassV1Inner {
-    fn new(executor: AotContractExecutor, casm: CompiledClassV1) -> Self {
+    fn new(executor: ContractExecutor, casm: CompiledClassV1) -> Self {
         NativeCompiledClassV1Inner { executor, casm }
     }
 }

crates/blockifier/src/execution/native/contract_class.rs

@@ -14,6 +14,7 @@ use crate::execution::contract_class::TrackedResource;
 use crate::execution::entry_point::{EntryPointExecutionContext, ExecutableCallEntryPoint};
 use crate::execution::errors::{EntryPointExecutionError, PostExecutionError, PreExecutionError};
 use crate::execution::native::contract_class::NativeCompiledClassV1;
+use crate::execution::native::run_dispatch::run_native_executor;
 use crate::execution::native::syscall_handler::NativeSyscallHandler;
 use crate::state::state_api::State;
 use crate::transaction::objects::ExecutionResourcesTraits;
@@ -57,11 +58,12 @@ pub fn execute_entry_point_call(
         .checked_sub(initial_budget)
         .ok_or(PreExecutionError::InsufficientEntryPointGas)?;
 
-    let execution_result = compiled_class.executor.run(
+    let execution_result = run_native_executor(
+        &compiled_class.executor,
         entry_point.selector.0,
         &syscall_handler.base.call.calldata.0.clone(),
         call_initial_gas,
-        Some(builtin_costs),
+        builtin_costs,
         &mut syscall_handler,
     );