Add global support for program caches. (#1140)

* Add global support for program caches.

* Update cairo-native dependency and fix stuff.

* Fix compilation errors.

Author: azteca1998

Cargo.lock

@@ -34,7 +34,7 @@ cairo-lang-runner = { workspace = true }
 cairo-lang-sierra = { workspace = true }
 cairo-lang-starknet = { workspace = true }
 cairo-lang-utils = { workspace = true }
-cairo-native = { git = "https://github.com/lambdaclass/cairo_native", rev = "4012a10b97530e208b76d42169aa9608a6a9d8fd", optional = true }
+cairo-native = { git = "https://github.com/lambdaclass/cairo_native", rev = "f668096bd6382066392cd563873dda5e7885a388", optional = true }
 cairo-vm = { workspace = true }
 flate2 = "1.0.25"
 getset = "0.1.2"

Cargo.toml

@@ -1,5 +1,6 @@
 #![deny(warnings)]
 
+use cairo_native::cache::ProgramCache;
 use cairo_vm::felt;
 use felt::{felt_str, Felt252};
 use lazy_static::lazy_static;
@@ -21,6 +22,12 @@ use starknet_in_rust::{
 };
 use std::{collections::HashMap, hint::black_box, sync::Arc};
 
+#[cfg(feature = "cairo-native")]
+use {
+    starknet_in_rust::utils::ClassHash,
+    std::{cell::RefCell, rc::Rc},
+};
+
 lazy_static! {
     // include_str! doesn't seem to work in CI
     static ref CONTRACT_CLASS: ContractClass = ContractClass::from_path(
@@ -48,18 +55,25 @@ fn scope<T>(f: impl FnOnce() -> T) -> T {
 // We don't use the cargo test harness because it uses
 // FnOnce calls for each test, that are merged in the flamegraph.
 fn main() {
-    deploy_account();
-    declare();
-    deploy();
-    invoke();
+    #[cfg(feature = "cairo-native")]
+    let program_cache = Rc::new(RefCell::new(ProgramCache::new(
+        starknet_in_rust::utils::get_native_context(),
+    )));
+
+    deploy_account(program_cache.clone());
+    declare(program_cache.clone());
+    deploy(program_cache.clone());
+    invoke(program_cache.clone());
 
     // The black_box ensures there's no tail-call optimization.
     // If not, the flamegraph ends up less nice.
     black_box(());
 }
 
 #[inline(never)]
-fn deploy_account() {
+fn deploy_account(
+    #[cfg(feature = "cairo-native")] program_cache: Rc<RefCell<ProgramCache<ClassHash>>>,
+) {
     const RUNS: usize = 500;
 
     let state_reader = Arc::new(InMemoryStateReader::default());
@@ -91,14 +105,19 @@ fn deploy_account() {
                 StarknetChainId::TestNet.to_felt(),
             )
             .unwrap();
-            internal_deploy_account.execute(&mut state_copy, block_context)
+            internal_deploy_account.execute(
+                &mut state_copy,
+                block_context,
+                #[cfg(feature = "cairo-native")]
+                Some(program_cache.clone()),
+            )
         })
         .unwrap();
     }
 }
 
 #[inline(never)]
-fn declare() {
+fn declare(#[cfg(feature = "cairo-native")] program_cache: Rc<RefCell<ProgramCache<ClassHash>>>) {
     const RUNS: usize = 5;
 
     let state_reader = Arc::new(InMemoryStateReader::default());
@@ -123,14 +142,19 @@ fn declare() {
             )
             .expect("couldn't create transaction");
 
-            declare_tx.execute(&mut cloned_state, block_context)
+            declare_tx.execute(
+                &mut cloned_state,
+                block_context,
+                #[cfg(feature = "cairo-native")]
+                Some(program_cache.clone()),
+            )
         })
         .unwrap();
     }
 }
 
 #[inline(never)]
-fn deploy() {
+fn deploy(#[cfg(feature = "cairo-native")] program_cache: Rc<RefCell<ProgramCache<ClassHash>>>) {
     const RUNS: usize = 8;
 
     let state_reader = Arc::new(InMemoryStateReader::default());
@@ -161,14 +185,19 @@ fn deploy() {
                 0.into(),
             )
             .unwrap();
-            internal_deploy.execute(&mut state_copy, block_context)
+            internal_deploy.execute(
+                &mut state_copy,
+                block_context,
+                #[cfg(feature = "cairo-native")]
+                Some(program_cache.clone()),
+            )
         })
         .unwrap();
     }
 }
 
 #[inline(never)]
-fn invoke() {
+fn invoke(#[cfg(feature = "cairo-native")] program_cache: Rc<RefCell<ProgramCache<ClassHash>>>) {
     const RUNS: usize = 100;
 
     let state_reader = Arc::new(InMemoryStateReader::default());
@@ -195,7 +224,14 @@ fn invoke() {
     )
     .unwrap();
 
-    let _deploy_exec_info = deploy.execute(&mut state, block_context).unwrap();
+    let _deploy_exec_info = deploy
+        .execute(
+            &mut state,
+            block_context,
+            #[cfg(feature = "cairo-native")]
+            Some(program_cache.clone()),
+        )
+        .unwrap();
 
     for _ in 0..RUNS {
         let mut state_copy = state.clone();
@@ -216,7 +252,13 @@ fn invoke() {
                 Some(Felt252::zero()),
             )
             .unwrap();
-            internal_invoke.execute(&mut state_copy, block_context, 2_000_000)
+            internal_invoke.execute(
+                &mut state_copy,
+                block_context,
+                2_000_000,
+                #[cfg(feature = "cairo-native")]
+                Some(program_cache.clone()),
+            )
         })
         .unwrap();
     }

bench/internals.rs

@@ -7,13 +7,6 @@
 // $ native_bench <n_executions> native <fibo|fact>
 // where fibo executes a fibonacci function and fact a factorial n times.
 
-#![cfg(feature = "cairo-native")]
-
-#[cfg(not(feature = "cairo-native"))]
-fn main() {
-    unimplemented!("This program should be compiled with the cairo-native feature");
-}
-
 use cairo_native::cache::ProgramCache;
 use cairo_native::context::NativeContext;
 use cairo_vm::felt::felt_str;
@@ -26,6 +19,7 @@ use starknet_in_rust::services::api::contract_classes::compiled_class::CompiledC
 use starknet_in_rust::state::state_api::State;
 use starknet_in_rust::transaction::DeployAccount;
 use starknet_in_rust::utils::calculate_sn_keccak;
+use starknet_in_rust::utils::get_native_context;
 use starknet_in_rust::CasmContractClass;
 use starknet_in_rust::EntryPointType;
 use starknet_in_rust::{
@@ -244,6 +238,7 @@ fn bench_erc20(executions: usize, native: bool) {
         static ref ERC20_DEPLOYMENT_CALLER_ADDRESS: Address = Address(0000.into());
     }
 
+    let program_cache = Rc::new(RefCell::new(ProgramCache::new(get_native_context())));
     let (erc20_address, mut state): (Address, CachedState<InMemoryStateReader>) = match native {
         true => {
             let erc20_sierra_class = include_bytes!("../starknet_programs/cairo2/erc20.sierra");
@@ -317,6 +312,7 @@ fn bench_erc20(executions: usize, native: bool) {
                     &mut tx_execution_context,
                     false,
                     block_context.invoke_tx_max_n_steps(),
+                    Some(program_cache.clone()),
                 )
                 .unwrap();
 
@@ -395,6 +391,7 @@ fn bench_erc20(executions: usize, native: bool) {
                     &mut tx_execution_context,
                     false,
                     block_context.invoke_tx_max_n_steps(),
+                    Some(program_cache.clone()),
                 )
                 .unwrap();
 
@@ -454,7 +451,7 @@ fn bench_erc20(executions: usize, native: bool) {
     // this will create the account and after that,
     // we can extract its address.
     let account1_address = account1_deploy_tx
-        .execute(&mut state, &Default::default())
+        .execute(&mut state, &Default::default(), Some(program_cache.clone()))
         .expect("failed to execute the deployment of account 1")
         .validate_info
         .expect("validate_info missing")
@@ -482,7 +479,7 @@ fn bench_erc20(executions: usize, native: bool) {
 
     // execute the deploy_account transaction and retrieve the deployed account address.
     let _account2_address = account2_deploy_tx
-        .execute(&mut state, &Default::default())
+        .execute(&mut state, &Default::default(), Some(program_cache.clone()))
         .expect("failed to execute the deployment of account 2")
         .validate_info
         .expect("validate_info missing")
@@ -494,9 +491,6 @@ fn bench_erc20(executions: usize, native: bool) {
     // calldata for transfering 123 tokens from account1 to account2
     let calldata = vec![Felt252::from(12), Felt252::from(123)];
 
-    let native_ctx = NativeContext::new();
-    let program_cache = Rc::new(RefCell::new(ProgramCache::new(&native_ctx)));
-
     for _ in 0..executions {
         let result = execute(
             &mut state.clone(),
@@ -550,14 +544,14 @@ fn execute(
     let mut resources_manager = ExecutionResourcesManager::default();
 
     exec_entry_point
-        .execute_with_native_cache(
+        .execute(
             state,
             &block_context,
             &mut resources_manager,
             &mut tx_execution_context,
             false,
             block_context.invoke_tx_max_n_steps(),
-            program_cache,
+            Some(program_cache),
         )
         .unwrap()
         .call_info

bench/native_bench.rs

@@ -5,6 +5,7 @@ edition = "2021"
 
 [features]
 default = ["with_mimalloc"]
+cairo-native = ["starknet_in_rust/cairo-native"]
 with_mimalloc = ["dep:mimalloc"]
 
 [dependencies]

cli/Cargo.toml

@@ -201,7 +201,13 @@ fn invoke_parser(
         transaction_hash.unwrap(),
     )?;
     let mut transactional_state = cached_state.create_transactional();
-    let _tx_info = internal_invoke.apply(&mut transactional_state, &BlockContext::default(), 0)?;
+    let _tx_info = internal_invoke.apply(
+        &mut transactional_state,
+        &BlockContext::default(),
+        0,
+        #[cfg(feature = "cairo-native")]
+        None,
+    )?;
     cached_state.apply_state_update(&StateDiff::from_cached_state(transactional_state.cache())?)?;
 
     let tx_hash = calculate_transaction_hash_common(
@@ -267,6 +273,8 @@ fn call_parser(
         &mut TransactionExecutionContext::default(),
         false,
         block_context.invoke_tx_max_n_steps(),
+        #[cfg(feature = "cairo-native")]
+        None,
     )?;
 
     let call_info = call_info.ok_or(TransactionError::CallInfoIsNone)?;

cli/src/main.rs

@@ -3,7 +3,8 @@ name = "contract_execution"
 version = "0.4.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+cairo-native = ["starknet_in_rust/cairo-native"]
 
 [dependencies]
 cairo-vm = { workspace = true }

examples/contract_execution/Cargo.toml

@@ -119,7 +119,12 @@ fn test_contract(
     .unwrap();
 
     let account_contract_address = internal_deploy
-        .execute(&mut state, &block_context)
+        .execute(
+            &mut state,
+            &block_context,
+            #[cfg(feature = "cairo-native")]
+            None,
+        )
         .expect("Account Deploy Failed")
         .call_info
         .unwrap()
@@ -155,7 +160,12 @@ fn test_contract(
     .expect("couldn't create declare transaction");
 
     declare_tx
-        .execute(&mut state, &block_context)
+        .execute(
+            &mut state,
+            &block_context,
+            #[cfg(feature = "cairo-native")]
+            None,
+        )
         .expect("could not declare the contract class");
 
     //* ----------------------------------------------------------
@@ -175,7 +185,13 @@ fn test_contract(
     .unwrap();
 
     let contract_address = deploy
-        .execute(&mut state, &block_context, 0)
+        .execute(
+            &mut state,
+            &block_context,
+            0,
+            #[cfg(feature = "cairo-native")]
+            None,
+        )
         .expect("could not deploy contract")
         .call_info
         .unwrap()
@@ -218,7 +234,15 @@ fn test_contract(
     )
     .unwrap();
 
-    let tx_exec_info = invoke_tx.execute(&mut state, &block_context, 0).unwrap();
+    let tx_exec_info = invoke_tx
+        .execute(
+            &mut state,
+            &block_context,
+            0,
+            #[cfg(feature = "cairo-native")]
+            None,
+        )
+        .unwrap();
 
     //* --------------------------------------------
     //*          Extract return values

examples/contract_execution/src/main.rs

@@ -3,7 +3,8 @@ name = "fuzzer"
 version = "0.4.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+cairo-native = ["starknet_in_rust/cairo-native"]
 
 [dependencies]
 honggfuzz = "0.5.55"

fuzzer/Cargo.toml

@@ -194,6 +194,8 @@ fn main() {
                     &mut tx_execution_context,
                     false,
                     block_context.invoke_tx_max_n_steps(),
+                    #[cfg(feature = "cairo-native")]
+                    None,
                 )
                 .unwrap();
             assert_eq!(call_info.unwrap(), expected_call_info);