Some lints

Author: cptartur

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

@@ -189,8 +189,8 @@ pub fn execute_call_entry_point(
             // } else {
             println!("Executing native entry point");
             execute_entry_point_call_native(
-                entry_point.clone(),
-                native_compiled_class_v1,
+                &entry_point,
+                &native_compiled_class_v1,
                 state,
                 cheatnet_state,
                 context,

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

@@ -1,13 +1,16 @@
+use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::entry_point::execute_call_entry_point;
+use crate::runtime_extensions::native::native_syscall_handler::BaseSyscallResult;
+use crate::state::CheatnetState;
 use blockifier::execution::call_info::CallInfo;
 use blockifier::execution::entry_point::CallEntryPoint;
 use blockifier::execution::execution_utils::update_remaining_gas;
-use blockifier::execution::syscalls::hint_processor::{SyscallExecutionError, ENTRYPOINT_FAILED_ERROR};
+use blockifier::execution::syscalls::hint_processor::{
+    ENTRYPOINT_FAILED_ERROR, SyscallExecutionError,
+};
 use blockifier::execution::syscalls::syscall_base::SyscallHandlerBase;
 use starknet_types_core::felt::Felt;
-use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::entry_point::execute_call_entry_point;
-use crate::runtime_extensions::native::native_syscall_handler::BaseSyscallResult;
-use crate::state::CheatnetState;
 
+#[expect(clippy::mut_mut)]
 #[allow(clippy::result_large_err)]
 pub fn execute_inner_call(
     syscall_handler_base: &mut SyscallHandlerBase,
@@ -61,4 +64,4 @@ pub fn execute_inner_call(
     }
 
     Ok(raw_retdata)
-}
+}

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

@@ -15,10 +15,14 @@ use starknet_api::contract_class::EntryPointType;
 use starknet_api::core::{ClassHash, ContractAddress, calculate_contract_address};
 use starknet_api::transaction::fields::{Calldata, ContractAddressSalt};
 
+// Copied from blockifer/src/execution/entry_point.rs
 #[allow(clippy::result_large_err)]
+#[expect(clippy::needless_pass_by_value)]
 pub fn execute_constructor_entry_point(
     state: &mut dyn State,
+    // region: Modified blockifer code
     cheatnet_state: &mut CheatnetState,
+    // endregion
     context: &mut EntryPointExecutionContext,
     ctor_context: ConstructorContext,
     calldata: Calldata,
@@ -54,6 +58,7 @@ pub fn execute_constructor_entry_point(
         initial_gas: *remaining_gas,
     };
 
+    // region: Modified blockifer code
     let call_info =
         execute_call_entry_point(&mut constructor_call, state, cheatnet_state, context, false)
             .map_err(|error| {
@@ -65,8 +70,11 @@ pub fn execute_constructor_entry_point(
             })?;
 
     Ok(call_info)
+    // endregion
 }
 
+#[expect(clippy::result_large_err)]
+// Copied from blockifer/src/execution/execution_utils.rs
 fn execute_deployment(
     state: &mut dyn State,
     cheatnet_state: &mut CheatnetState,
@@ -108,6 +116,8 @@ fn execute_deployment(
     )
 }
 
+#[expect(clippy::match_bool, clippy::result_large_err)]
+// Copied from blockifer/src/execution/syscalls/syscall_base.rs
 pub fn deploy(
     syscall_handler_base: &mut SyscallHandlerBase,
     cheatnet_state: &mut CheatnetState,
@@ -150,6 +160,7 @@ pub fn deploy(
         storage_address: deployed_contract_address,
         caller_address: deployer_address,
     };
+    // region: Modified blockifer code
     let call_info = execute_deployment(
         syscall_handler_base.state,
         cheatnet_state,
@@ -158,5 +169,6 @@ pub fn deploy(
         constructor_calldata,
         remaining_gas,
     )?;
+    // endregion
     Ok((deployed_contract_address, call_info))
 }

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

@@ -19,11 +19,13 @@ use blockifier::utils::add_maps;
 use cairo_native::execution_result::{BuiltinStats, ContractExecutionResult};
 use cairo_native::utils::BuiltinCosts;
 use cairo_vm::types::builtin_name::BuiltinName;
+use std::collections::HashMap;
 use std::default::Default;
 
+#[expect(clippy::result_large_err)]
 pub(crate) fn execute_entry_point_call_native(
-    call: ExecutableCallEntryPoint,
-    native_compiled_class_v1: NativeCompiledClassV1,
+    call: &ExecutableCallEntryPoint,
+    native_compiled_class_v1: &NativeCompiledClassV1,
     state: &mut dyn State,
     cheatnet_state: &mut CheatnetState, // Added parameter
     context: &mut EntryPointExecutionContext,
@@ -39,8 +41,8 @@ pub(crate) fn execute_entry_point_call_native(
 
     Ok(CallInfoWithExecutionData {
         call_info,
-        syscall_usage_vm_resources: Default::default(),
-        syscall_usage_sierra_gas: Default::default(),
+        syscall_usage_vm_resources: HashMap::default(),
+        syscall_usage_sierra_gas: HashMap::default(),
         vm_trace: None,
     })
 }
@@ -49,8 +51,8 @@ pub(crate) fn execute_entry_point_call_native(
 // todo(rodrigo): add an `entry point not found` test for Native
 #[allow(clippy::result_large_err)]
 pub fn execute_entry_point_call(
-    call: ExecutableCallEntryPoint,
-    compiled_class: NativeCompiledClassV1,
+    call: &ExecutableCallEntryPoint,
+    compiled_class: &NativeCompiledClassV1,
     // state: &mut dyn State,
     // context: &mut EntryPointExecutionContext,
     mut syscall_handler: CheatableNativeSyscallHandler,
@@ -124,6 +126,7 @@ pub fn execute_entry_point_call(
 
 // Copied from blockifier
 #[allow(clippy::result_large_err)]
+#[expect(clippy::needless_pass_by_value)]
 fn create_callinfo(
     call_result: ContractExecutionResult,
     syscall_handler: CheatableNativeSyscallHandler<'_>,

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

@@ -1,4 +1,4 @@
+mod call;
+mod deploy;
 pub mod execution;
 pub mod native_syscall_handler;
-mod deploy;
-mod call;

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

@@ -96,6 +96,7 @@ impl CheatableNativeSyscallHandler<'_> {
         Ok(())
     }
 
+    // Copied from blockifer/src/exection/native/syscall_handler.rs
     #[allow(clippy::result_large_err)]
     fn execute_inner_call(
         &mut self,
@@ -110,9 +111,10 @@ impl CheatableNativeSyscallHandler<'_> {
         ) -> SyscallExecutionError,
     ) -> SyscallResult<Retdata> {
         let entry_point_clone = entry_point.clone();
+        // region: Modified blockifier code
         let raw_data = execute_inner_call(
             &mut self.native_syscall_handler.base,
-            &mut self.cheatnet_state,
+            self.cheatnet_state,
             entry_point,
             remaining_gas,
         )
@@ -131,6 +133,7 @@ impl CheatableNativeSyscallHandler<'_> {
                 )),
             )
         })?;
+        // endregion
         Ok(Retdata(raw_data))
     }
 
@@ -359,7 +362,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
 
         let (deployed_contract_address, call_info) = deploy(
             &mut self.native_syscall_handler.base,
-            &mut self.cheatnet_state,
+            self.cheatnet_state,
             ClassHash(class_hash),
             ContractAddressSalt(contract_address_salt),
             Calldata(Arc::new(calldata.to_vec())),
@@ -379,6 +382,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .replace_class(class_hash, remaining_gas)
     }
 
+    // Copied from blockifier/src/execution/native/syscall_handler.rs
     fn library_call(
         &mut self,
         class_hash: Felt,
@@ -433,6 +437,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .0)
     }
 
+    // Copied from blockifier/src/execution/native/syscall_handler.rs
     fn call_contract(
         &mut self,
         address: Felt,