Review suggestions

Author: cptartur

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

@@ -89,6 +89,7 @@ pub fn deploy_syscall(
         deployer_address
     };
 
+    // region: Modified blockifier code
     let deployed_contract_address =
         if let Some(contract_address) = cheatnet_state.next_address_for_deployment() {
             contract_address
@@ -100,6 +101,7 @@ pub fn deploy_syscall(
                 deployer_address_for_calculation,
             )?
         };
+    // endregion
 
     let ctor_context = ConstructorContext {
         class_hash: request.class_hash,

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

@@ -1,132 +1,13 @@
-use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::entry_point::{
-    ExecuteCallEntryPointExtraOptions, execute_call_entry_point,
-};
+use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::cheated_syscalls::execute_deployment;
 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, CallType, ConstructorContext, ConstructorEntryPointExecutionResult,
-    EntryPointExecutionContext, handle_empty_constructor,
-};
-use blockifier::execution::errors::ConstructorEntryPointExecutionError;
+use blockifier::execution::entry_point::ConstructorContext;
 use blockifier::execution::syscalls::syscall_base::SyscallHandlerBase;
 use blockifier::execution::syscalls::vm_syscall_utils::SyscallSelector;
-use blockifier::state::errors::StateError;
-use blockifier::state::state_api::State;
-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,
-    remaining_gas: &mut u64,
-) -> ConstructorEntryPointExecutionResult<CallInfo> {
-    // Ensure the class is declared (by reading it).
-    let compiled_class = state
-        .get_compiled_class(ctor_context.class_hash)
-        .map_err(|error| {
-            ConstructorEntryPointExecutionError::new(error.into(), &ctor_context, None)
-        })?;
-    let Some(constructor_selector) = compiled_class.constructor_selector() else {
-        // region: Modified blockifer code
-        cheatnet_state
-            .trace_data
-            .add_deploy_without_constructor_node();
-        // endregion
-        // Contract has no constructor.
-        return handle_empty_constructor(
-            compiled_class,
-            context,
-            &ctor_context,
-            calldata,
-            *remaining_gas,
-        )
-        .map_err(|error| ConstructorEntryPointExecutionError::new(error, &ctor_context, None));
-    };
-
-    let mut constructor_call = CallEntryPoint {
-        class_hash: None,
-        code_address: ctor_context.code_address,
-        entry_point_type: EntryPointType::Constructor,
-        entry_point_selector: constructor_selector,
-        calldata,
-        storage_address: ctor_context.storage_address,
-        caller_address: ctor_context.caller_address,
-        call_type: CallType::Call,
-        initial_gas: *remaining_gas,
-    };
-
-    // region: Modified blockifer code
-    let call_info = execute_call_entry_point(
-        &mut constructor_call,
-        state,
-        cheatnet_state,
-        context,
-        remaining_gas,
-        &ExecuteCallEntryPointExtraOptions {
-            trace_data_handled_by_revert_call: false,
-        },
-    )
-    .map_err(|error| {
-        ConstructorEntryPointExecutionError::new(error, &ctor_context, Some(constructor_selector))
-    })?;
-
-    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,
-    context: &mut EntryPointExecutionContext,
-    ctor_context: ConstructorContext,
-    constructor_calldata: Calldata,
-    remaining_gas: &mut u64,
-) -> ConstructorEntryPointExecutionResult<CallInfo> {
-    // Address allocation in the state is done before calling the constructor, so that it is
-    // visible from it.
-    let deployed_contract_address = ctor_context.storage_address;
-    let current_class_hash =
-        state
-            .get_class_hash_at(deployed_contract_address)
-            .map_err(|error| {
-                ConstructorEntryPointExecutionError::new(error.into(), &ctor_context, None)
-            })?;
-    if current_class_hash != ClassHash::default() {
-        return Err(ConstructorEntryPointExecutionError::new(
-            StateError::UnavailableContractAddress(deployed_contract_address).into(),
-            &ctor_context,
-            None,
-        ));
-    }
-
-    state
-        .set_class_hash_at(deployed_contract_address, ctor_context.class_hash)
-        .map_err(|error| {
-            ConstructorEntryPointExecutionError::new(error.into(), &ctor_context, None)
-        })?;
-
-    execute_constructor_entry_point(
-        state,
-        cheatnet_state,
-        context,
-        ctor_context,
-        constructor_calldata,
-        remaining_gas,
-    )
-}
-
 #[expect(clippy::match_bool, clippy::result_large_err)]
 // Copied from blockifer/src/execution/syscalls/syscall_base.rs
 pub fn deploy(
@@ -140,12 +21,13 @@ pub fn deploy(
 ) -> BaseSyscallResult<(ContractAddress, CallInfo)> {
     syscall_handler_base
         .increment_syscall_linear_factor_by(&SyscallSelector::Deploy, constructor_calldata.0.len());
+
+    // TODO(#3790) support for reject
     // let versioned_constants = &syscall_handler_base
     //     .context
     //     .tx_context
     //     .block_context
     //     .versioned_constants;
-    // TODO(#3790) support for reject
     // if should_reject_deploy(
     //     versioned_constants.disable_deploy_in_validation_mode,
     //     syscall_handler_base.context.execution_mode,
@@ -176,7 +58,7 @@ pub fn deploy(
         syscall_handler_base.state,
         cheatnet_state,
         syscall_handler_base.context,
-        ctor_context,
+        &ctor_context,
         constructor_calldata,
         remaining_gas,
     )?;

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

@@ -48,28 +48,23 @@ pub(crate) fn execute_entry_point_call_native(
     })
 }
 
-// Copied from blockifier
-// todo(rodrigo): add an `entry point not found` test for Native
+// Based on https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/entry_point_execution.rs#L20
 #[allow(clippy::result_large_err)]
-pub fn execute_entry_point_call(
+fn execute_entry_point_call(
     call: &ExecutableCallEntryPoint,
     compiled_class: &NativeCompiledClassV1,
-    // state: &mut dyn State,
-    // context: &mut EntryPointExecutionContext,
+    // region: Modified blockifier code
     syscall_handler: &mut CheatableNativeSyscallHandler,
+    // endregion
 ) -> EntryPointExecutionResult<CallInfo> {
     let entry_point = compiled_class.get_entry_point(&call.type_and_selector())?;
 
-    // let mut syscall_handler: NativeSyscallHandler<'_> =
-    //     NativeSyscallHandler::new(call, state, context);
-
     let gas_costs = &syscall_handler
         .native_syscall_handler
         .base
         .context
         .gas_costs();
     let builtin_costs = BuiltinCosts {
-        // todo(rodrigo): Unsure of what value `const` means, but 1 is the right value.
         r#const: 1,
         pedersen: gas_costs.builtins.pedersen,
         bitwise: gas_costs.builtins.bitwise,
@@ -125,7 +120,7 @@ pub fn execute_entry_point_call(
     create_callinfo(call_result, syscall_handler)
 }
 
-// Copied from blockifier
+// Copied from https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/entry_point_execution.rs#L73
 #[allow(clippy::result_large_err)]
 fn create_callinfo(
     call_result: ContractExecutionResult,

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

@@ -38,6 +38,7 @@ impl CheatableNativeSyscallHandler<'_> {
         self.native_syscall_handler.unrecoverable_error.take()
     }
 
+    // Copied from https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L80
     /// Handles all gas-related logics, syscall usage counting and perform additional checks. In
     /// native, we need to explicitly call this method at the beginning of each syscall.
     #[allow(clippy::result_large_err)]
@@ -98,7 +99,7 @@ impl CheatableNativeSyscallHandler<'_> {
         Ok(())
     }
 
-    // Copied from blockifer/src/exection/native/syscall_handler.rs
+    // Based on https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L153
     #[allow(clippy::result_large_err)]
     fn execute_inner_call(
         &mut self,
@@ -113,7 +114,6 @@ 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,
             self.cheatnet_state,
@@ -135,10 +135,10 @@ impl CheatableNativeSyscallHandler<'_> {
                 )),
             )
         })?;
-        // endregion
         Ok(Retdata(raw_data))
     }
 
+    // Copied from https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L124
     fn handle_error(&mut self, remaining_gas: &mut u64, error: SyscallExecutionError) -> Vec<Felt> {
         // In case of more than one inner call and because each inner call has their own
         // syscall handler, if there is an unrecoverable error at call `n` it will create a
@@ -263,7 +263,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .tx_info
             .nonce
             .unwrap_or(original_data.tx_info.nonce);
-        // TODO(#3790) impl conversions
+        // TODO(#3790) implement conversions
         let resource_bounds = cheated_data.tx_info.resource_bounds.map_or(
             original_data.tx_info.resource_bounds,
             |rb| {
@@ -336,6 +336,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
         })
     }
 
+    // Based on https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L322
     fn deploy(
         &mut self,
         class_hash: Felt,
@@ -355,6 +356,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
 
         self.pre_execute_syscall(remaining_gas, total_gas_cost, SyscallSelector::Deploy)?;
 
+        // region: Modified blockifier code
         let (deployed_contract_address, call_info) = deploy(
             &mut self.native_syscall_handler.base,
             self.cheatnet_state,
@@ -364,6 +366,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             deploy_from_zero,
             remaining_gas,
         )
+        // endregion
         .map_err(|err| self.handle_error(remaining_gas, err))?;
 
         let constructor_retdata = call_info.execution.retdata.0[..].to_vec();
@@ -377,7 +380,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .replace_class(class_hash, remaining_gas)
     }
 
-    // Copied from blockifier/src/execution/native/syscall_handler.rs
+    // Based on from https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L399
     fn library_call(
         &mut self,
         class_hash: Felt,
@@ -432,7 +435,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .0)
     }
 
-    // Copied from blockifier/src/execution/native/syscall_handler.rs
+    // Based on https://github.com/software-mansion-labs/sequencer/blob/b6d1c0b354d84225ab9c47f8ff28663d22e84d19/crates/blockifier/src/execution/native/syscall_handler.rs#L444
     fn call_contract(
         &mut self,
         address: Felt,
@@ -714,6 +717,7 @@ impl StarknetSyscallHandler for &mut CheatableNativeSyscallHandler<'_> {
             .get_class_hash_at(contract_address, remaining_gas)
     }
 
+    // TODO(#3790) Support cheating meta_tx_v0
     fn meta_tx_v0(
         &mut self,
         address: Felt,