Handle deploy syscall in outer runtime

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

@@ -5,17 +5,15 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 use blockifier::context::TransactionContext;
 use blockifier::execution::common_hints::ExecutionMode;
 use blockifier::execution::execution_utils::ReadOnlySegment;
-use blockifier::execution::syscalls::hint_processor::create_retdata_segment;
 use blockifier::execution::syscalls::hint_processor::{
     INVALID_ARGUMENT, SyscallExecutionError, SyscallHintProcessor,
 };
 use blockifier::execution::syscalls::syscall_base::SyscallResult;
 use blockifier::execution::syscalls::vm_syscall_utils::{
-    CallContractRequest, CallContractResponse, DeployRequest, DeployResponse, EmptyRequest,
-    GetBlockHashRequest, GetBlockHashResponse, GetExecutionInfoResponse, LibraryCallRequest,
-    LibraryCallResponse, MetaTxV0Request, MetaTxV0Response, StorageReadRequest,
-    StorageReadResponse, StorageWriteRequest, StorageWriteResponse, SyscallSelector,
-    TryExtractRevert,
+    CallContractRequest, CallContractResponse, EmptyRequest, GetBlockHashRequest,
+    GetBlockHashResponse, GetExecutionInfoResponse, LibraryCallRequest, LibraryCallResponse,
+    MetaTxV0Request, MetaTxV0Response, StorageReadRequest, StorageReadResponse,
+    StorageWriteRequest, StorageWriteResponse, SyscallSelector, TryExtractRevert,
 };
 use blockifier::execution::{call_info::CallInfo, entry_point::ConstructorContext};
 use blockifier::state::errors::StateError;
@@ -39,7 +37,7 @@ use starknet_api::transaction::fields::TransactionSignature;
 use starknet_api::transaction::{TransactionHasher, TransactionOptions, signed_tx_version};
 use starknet_api::{
     contract_class::EntryPointType,
-    core::{ClassHash, ContractAddress, Nonce, calculate_contract_address},
+    core::{ClassHash, ContractAddress, Nonce},
     transaction::{
         InvokeTransactionV0, TransactionVersion,
         fields::{Calldata, Fee},
@@ -65,68 +63,6 @@ pub fn get_execution_info_syscall(
     })
 }
 
-// blockifier/src/execution/syscalls/mod.rs:222 (deploy_syscall)
-pub fn deploy_syscall(
-    request: DeployRequest,
-    vm: &mut VirtualMachine,
-    syscall_handler: &mut SyscallHintProcessor<'_>,
-    cheatnet_state: &mut CheatnetState,
-    remaining_gas: &mut u64,
-) -> SyscallResult<DeployResponse> {
-    // Increment the Deploy syscall's linear cost counter by the number of elements in the
-    // constructor calldata
-    syscall_handler.base.increment_syscall_linear_factor_by(
-        &SyscallSelector::Deploy,
-        request.constructor_calldata.0.len(),
-    );
-
-    let deployer_address = syscall_handler.base.call.storage_address;
-    let deployer_address_for_calculation = if request.deploy_from_zero {
-        ContractAddress::default()
-    } else {
-        deployer_address
-    };
-
-    // region: Modified blockifier code
-    let deployed_contract_address =
-        if let Some(contract_address) = cheatnet_state.next_address_for_deployment() {
-            contract_address
-        } else {
-            calculate_contract_address(
-                request.contract_address_salt,
-                request.class_hash,
-                &request.constructor_calldata,
-                deployer_address_for_calculation,
-            )?
-        };
-    // endregion
-
-    let ctor_context = ConstructorContext {
-        class_hash: request.class_hash,
-        code_address: Some(deployed_contract_address),
-        storage_address: deployed_contract_address,
-        caller_address: deployer_address,
-    };
-    let call_info = execute_deployment(
-        syscall_handler.base.state,
-        cheatnet_state,
-        syscall_handler.base.context,
-        &ctor_context,
-        request.constructor_calldata,
-        remaining_gas,
-    )?;
-
-    let constructor_retdata =
-        create_retdata_segment(vm, syscall_handler, &call_info.execution.retdata.0)?;
-
-    syscall_handler.base.inner_calls.push(call_info);
-
-    Ok(DeployResponse {
-        contract_address: deployed_contract_address,
-        constructor_retdata,
-    })
-}
-
 // blockifier/src/execution/execution_utils.rs:217 (execute_deployment)
 pub fn execute_deployment(
     state: &mut dyn State,

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

@@ -1,12 +1,12 @@
 use std::marker::PhantomData;
 
 use crate::state::CheatnetState;
-use blockifier::execution::entry_point::{CallEntryPoint, CallType};
+use blockifier::execution::entry_point::{CallEntryPoint, CallType, ConstructorContext};
 use blockifier::execution::syscalls::hint_processor::{OUT_OF_GAS_ERROR, SyscallHintProcessor};
 use blockifier::execution::syscalls::syscall_executor::SyscallExecutor;
 use blockifier::execution::syscalls::vm_syscall_utils::{
-    CallContractRequest, LibraryCallRequest, RevertData, SingleSegmentResponse,
-    SyscallExecutorBaseError, SyscallRequestWrapper, SyscallSelector,
+    CallContractRequest, DeployRequest, DeployResponse, LibraryCallRequest, RevertData,
+    SingleSegmentResponse, SyscallExecutorBaseError, SyscallRequestWrapper, SyscallSelector,
 };
 use blockifier::execution::{
     execution_utils::ReadOnlySegment,
@@ -17,7 +17,7 @@ use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
 use runtime::{ExtendedRuntime, ExtensionLogic, SyscallHandlingResult};
 use starknet_api::contract_class::EntryPointType;
-use starknet_api::core::ContractAddress;
+use starknet_api::core::{ContractAddress, calculate_contract_address};
 use starknet_api::execution_resources::GasAmount;
 use starknet_types_core::felt::Felt;
 
@@ -29,6 +29,7 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::rpc::{
 };
 
 use super::cheatable_starknet_runtime_extension::CheatableStarknetRuntime;
+use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::cheated_syscalls::execute_deployment;
 use conversions::string::TryFromHexStr;
 use runtime::starknet::constants::TEST_ADDRESS;
 
@@ -68,9 +69,13 @@ impl<'a> ExtensionLogic for CallToBlockifierExtension<'a> {
 
                 Ok(SyscallHandlingResult::Handled)
             }
+            SyscallSelector::Deploy => {
+                execute_syscall::<DeployRequest>(selector, vm, extended_runtime)?;
+
+                Ok(SyscallHandlingResult::Handled)
+            }
             SyscallSelector::DelegateCall
             | SyscallSelector::DelegateL1Handler
-            | SyscallSelector::Deploy
             | SyscallSelector::EmitEvent
             | SyscallSelector::GetBlockHash
             | SyscallSelector::GetBlockNumber
@@ -179,6 +184,68 @@ impl ExecuteCall for LibraryCallRequest {
     }
 }
 
+impl ExecuteCall for DeployRequest {
+    fn execute_call(
+        self: DeployRequest,
+        syscall_handler: &mut SyscallHintProcessor,
+        cheatnet_state: &mut CheatnetState,
+        remaining_gas: &mut u64,
+    ) -> CallResult {
+        // Increment the Deploy syscall's linear cost counter by the number of elements in the
+        // constructor calldata
+        syscall_handler.base.increment_syscall_linear_factor_by(
+            &SyscallSelector::Deploy,
+            self.constructor_calldata.0.len(),
+        );
+
+        let deployer_address = syscall_handler.base.call.storage_address;
+        let deployer_address_for_calculation = if self.deploy_from_zero {
+            ContractAddress::default()
+        } else {
+            deployer_address
+        };
+
+        // region: Modified blockifier code
+        let deployed_contract_address =
+            if let Some(contract_address) = cheatnet_state.next_address_for_deployment() {
+                contract_address
+            } else {
+                calculate_contract_address(
+                    self.contract_address_salt,
+                    self.class_hash,
+                    &self.constructor_calldata,
+                    deployer_address_for_calculation,
+                )
+                .expect("Failed to calculate contract address")
+            };
+        // endregion
+
+        let ctor_context = ConstructorContext {
+            class_hash: self.class_hash,
+            code_address: Some(deployed_contract_address),
+            storage_address: deployed_contract_address,
+            caller_address: deployer_address,
+        };
+        let exec_result = execute_deployment(
+            syscall_handler.base.state,
+            cheatnet_state,
+            syscall_handler.base.context,
+            &ctor_context,
+            self.constructor_calldata,
+            remaining_gas,
+        );
+
+        let result =
+            CallResult::from_execution_result_deploy(&exec_result, &deployed_contract_address);
+
+        if let Ok(call_info) = exec_result {
+            syscall_handler.base.inner_calls.push(call_info);
+        }
+
+        result
+    }
+}
+
 // crates/blockifier/src/execution/syscalls/vm_syscall_utils.rs:677 (execute_syscall)
 fn execute_syscall<Request: ExecuteCall + SyscallRequest>(
     selector: SyscallSelector,
@@ -249,7 +316,7 @@ fn write_call_response(
     gas_counter: u64,
     call_result: CallResult,
 ) -> Result<(), HintError> {
-    let response_wrapper: SyscallResponseWrapper<SingleSegmentResponse> = match call_result {
+    match call_result {
         CallResult::Success { ret_data } => {
             let memory_segment_start_ptr = syscall_handler.read_only_segments.allocate(
                 vm,
@@ -260,7 +327,7 @@ fn write_call_response(
                     .collect::<Vec<MaybeRelocatable>>(),
             )?;
 
-            SyscallResponseWrapper::Success {
+            SyscallResponseWrapper::<SingleSegmentResponse>::Success {
                 gas_counter,
                 response: SingleSegmentResponse {
                     segment: ReadOnlySegment {
@@ -269,19 +336,46 @@ fn write_call_response(
                     },
                 },
             }
+            .write(vm, &mut syscall_handler.syscall_ptr)?;
         }
         CallResult::Failure(failure_type) => match failure_type {
-            CallFailure::Panic { panic_data } => SyscallResponseWrapper::Failure {
-                gas_counter,
-                revert_data: RevertData::new_normal(panic_data),
-            },
+            CallFailure::Panic { panic_data } => {
+                SyscallResponseWrapper::<SingleSegmentResponse>::Failure {
+                    gas_counter,
+                    revert_data: RevertData::new_normal(panic_data),
+                }
+                .write(vm, &mut syscall_handler.syscall_ptr)?;
+            }
             CallFailure::Error { msg } => {
                 return Err(HintError::CustomHint(Box::from(msg.to_string())));
             }
         },
-    };
+        CallResult::DeploySuccess {
+            ret_data,
+            contract_address,
+        } => {
+            let memory_segment_start_ptr = syscall_handler.read_only_segments.allocate(
+                vm,
+                &ret_data
+                    .clone()
+                    .into_iter()
+                    .map(MaybeRelocatable::Int)
+                    .collect::<Vec<MaybeRelocatable>>(),
+            )?;
 
-    response_wrapper.write(vm, &mut syscall_handler.syscall_ptr)?;
+            SyscallResponseWrapper::Success {
+                gas_counter,
+                response: DeployResponse {
+                    contract_address,
+                    constructor_retdata: ReadOnlySegment {
+                        start_ptr: memory_segment_start_ptr,
+                        length: ret_data.len(),
+                    },
+                },
+            }
+            .write(vm, &mut syscall_handler.syscall_ptr)?;
+        }
+    }
 
     Ok(())
 }

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/rpc.rs

@@ -34,7 +34,13 @@ pub struct UsedResources {
 /// Enum representing possible call execution result, along with the data
 #[derive(Debug, Clone, CairoSerialize)]
 pub enum CallResult {
-    Success { ret_data: Vec<Felt> },
+    Success {
+        ret_data: Vec<Felt>,
+    },
+    DeploySuccess {
+        ret_data: Vec<Felt>,
+        contract_address: ContractAddress,
+    },
     Failure(CallFailure),
 }
 
@@ -115,6 +121,9 @@ impl CallFailure {
                     msg: ByteArray::from(msg.as_str()),
                 }
             }
+            EntryPointExecutionError::CairoRunError(err) => CallFailure::Error {
+                msg: ByteArray::from(err.to_string().as_str()),
+            },
             error => {
                 let error_string = error.to_string();
                 if let Some(panic_data) = try_extract_panic_data(&error_string) {
@@ -141,6 +150,35 @@ impl CallResult {
         }
     }
 
+    #[must_use]
+    pub fn from_execution_result_deploy(
+        result: &EntryPointExecutionResult<CallInfo>,
+        contract_address: &ContractAddress,
+    ) -> Self {
+        match result {
+            Ok(call_info) => Self::from_non_error_deploy(call_info, contract_address),
+            Err(err) => {
+                Self::from_err(err, &AddressOrClassHash::ContractAddress(*contract_address))
+            }
+        }
+    }
+
+    #[must_use]
+    pub fn from_non_error_deploy(call_info: &CallInfo, contract_address: &ContractAddress) -> Self {
+        let return_data = &call_info.execution.retdata.0;
+
+        if call_info.execution.failed {
+            return CallResult::Failure(CallFailure::Panic {
+                panic_data: return_data.clone(),
+            });
+        }
+
+        CallResult::DeploySuccess {
+            ret_data: return_data.clone(),
+            contract_address: *contract_address,
+        }
+    }
+
     #[must_use]
     pub fn from_non_error(call_info: &CallInfo) -> Self {
         let return_data = &call_info.execution.retdata.0;

crates/cheatnet/src/runtime_extensions/cheatable_starknet_runtime_extension.rs

@@ -71,14 +71,6 @@ impl<'a> ExtensionLogic for CheatableStarknetRuntimeExtension<'a> {
                     SyscallSelector::LibraryCall,
                 )
                 .map(|()| SyscallHandlingResult::Handled),
-            SyscallSelector::Deploy => self
-                .execute_syscall(
-                    syscall_handler,
-                    vm,
-                    cheated_syscalls::deploy_syscall,
-                    SyscallSelector::Deploy,
-                )
-                .map(|()| SyscallHandlingResult::Handled),
             SyscallSelector::GetBlockHash => self
                 .execute_syscall(
                     syscall_handler,
@@ -113,6 +105,7 @@ impl<'a> ExtensionLogic for CheatableStarknetRuntimeExtension<'a> {
                 .map(|()| SyscallHandlingResult::Handled),
             SyscallSelector::DelegateCall
             | SyscallSelector::DelegateL1Handler
+            | SyscallSelector::Deploy
             | SyscallSelector::EmitEvent
             | SyscallSelector::GetBlockNumber
             | SyscallSelector::GetBlockTimestamp

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

@@ -276,6 +276,7 @@ impl<'a> ExtensionLogic for ForgeExtension<'a> {
                     CallResult::Failure(CallFailure::Error { msg }) => Err(
                         EnhancedHintError::from(HintError::CustomHint(Box::from(msg.to_string()))),
                     ),
+                    _ => unreachable!(),
                 }
             }
             "read_txt" => {

crates/cheatnet/tests/common/mod.rs

@@ -71,6 +71,7 @@ pub fn recover_data(output: CallResult) -> Vec<Felt> {
             CallFailure::Panic { panic_data, .. } => panic_data,
             CallFailure::Error { msg, .. } => panic!("Call failed with message: {msg}"),
         },
+        CallResult::DeploySuccess { .. } => unreachable!(),
     }
 }