Remove deploy_at as cheatcode (#3676)

Towards #3659

commit-id:b3b58bf4

---

**Stack**:
- #3700
- #3699
- #3695
- #3676 ⬅


⚠️ *Part of a stack created by [spr](https://github.com/ejoffe/spr). Do
not merge manually using the UI - doing so may have unexpected results.*

Author: ddoktorski

CHANGELOG.md

@@ -30,7 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- `deploy` method on `ContractClass` instance now fails immediately upon encountering an error, preventing the error from being caught. This change aligns with the behavior of the `deploy_syscall` on the network
+- `deploy` and `deploy_at` methods on `ContractClass` instance now fail immediately upon encountering an error, preventing the error from being caught. This change aligns with the behavior of the `deploy_syscall` on the network
 
 ### Cast
 

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

@@ -94,12 +94,17 @@ pub fn deploy_syscall(
         deployer_address
     };
 
-    let deployed_contract_address = calculate_contract_address(
-        request.contract_address_salt,
-        request.class_hash,
-        &request.constructor_calldata,
-        deployer_address_for_calculation,
-    )?;
+    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,
+            )?
+        };
 
     let ctor_context = ConstructorContext {
         class_hash: request.class_hash,

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

@@ -11,7 +11,6 @@ use crate::runtime_extensions::{
     forge_runtime_extension::cheatcodes::{
         CheatcodeError,
         declare::declare,
-        deploy::deploy_at,
         generate_random_felt::generate_random_felt,
         get_class_hash::get_class_hash,
         l1_handler_execute::l1_handler_execute,
@@ -26,7 +25,6 @@ use blockifier::context::TransactionContext;
 use blockifier::execution::call_info::{CallExecution, CallInfo};
 use blockifier::execution::contract_class::TrackedResource;
 use blockifier::execution::entry_point::CallEntryPoint;
-use blockifier::execution::syscalls::syscall_executor::SyscallExecutor;
 use blockifier::execution::syscalls::vm_syscall_utils::{SyscallSelector, SyscallUsageMap};
 use blockifier::state::errors::StateError;
 use cairo_vm::vm::runners::cairo_runner::CairoRunner;
@@ -191,25 +189,14 @@ impl<'a> ExtensionLogic for ForgeExtension<'a> {
 
                 handle_declare_deploy_result(declare(*state, &contract_name, self.contracts_data))
             }
-            "deploy_at" => {
-                let class_hash = input_reader.read()?;
-                let calldata: Vec<_> = input_reader.read()?;
+            // Internal cheatcode used to pass a contract address when calling `deploy_at`.
+            "set_deploy_at_address" => {
                 let contract_address = input_reader.read()?;
-                let cheatnet_runtime = &mut extended_runtime.extended_runtime;
-                let syscall_handler = &mut cheatnet_runtime.extended_runtime.hint_handler;
 
-                syscall_handler.increment_syscall_count_by(&SyscallSelector::Deploy, 1);
-                syscall_handler
-                    .base
-                    .increment_syscall_linear_factor_by(&SyscallSelector::Deploy, calldata.len());
+                let state = &mut *extended_runtime.extended_runtime.extension.cheatnet_state;
+                state.set_next_deploy_at_address(contract_address);
 
-                handle_declare_deploy_result(deploy_at(
-                    syscall_handler,
-                    cheatnet_runtime.extension.cheatnet_state,
-                    &class_hash,
-                    &calldata,
-                    contract_address,
-                ))
+                Ok(CheatcodeHandlingResult::from_serializable(()))
             }
             "precalculate_address" => {
                 let class_hash = input_reader.read()?;
@@ -223,7 +210,7 @@ impl<'a> ExtensionLogic for ForgeExtension<'a> {
 
                 Ok(CheatcodeHandlingResult::from_serializable(contract_address))
             }
-            // Internal cheat code to guarantee unique salts for each deployment
+            // Internal cheatcode to guarantee unique salts for each deployment
             // when deploying via a method of the `ContractClass` struct.
             "get_salt" => {
                 let state = &mut *extended_runtime.extended_runtime.extension.cheatnet_state;

crates/cheatnet/src/state.rs

@@ -383,6 +383,7 @@ pub struct CheatnetState {
     pub detected_events: Vec<Event>,
     pub detected_messages_to_l1: Vec<MessageToL1>,
     pub deploy_salt_base: u32,
+    pub next_deploy_at_address: Option<ContractAddress>,
     pub block_info: BlockInfo,
     pub trace_data: TraceData,
     pub encountered_errors: EncounteredErrors,
@@ -410,6 +411,7 @@ impl Default for CheatnetState {
             detected_events: vec![],
             detected_messages_to_l1: vec![],
             deploy_salt_base: 0,
+            next_deploy_at_address: None,
             block_info: SerializableBlockInfo::default().into(),
             trace_data: TraceData {
                 current_call_stack: NotEmptyCallStack::from(test_call),
@@ -477,6 +479,14 @@ impl CheatnetState {
         self.deploy_salt_base += 1;
     }
 
+    pub fn set_next_deploy_at_address(&mut self, address: ContractAddress) {
+        self.next_deploy_at_address = Some(address);
+    }
+
+    pub fn next_address_for_deployment(&mut self) -> Option<ContractAddress> {
+        self.next_deploy_at_address.take()
+    }
+
     #[must_use]
     pub fn get_salt(&self) -> ContractAddressSalt {
         ContractAddressSalt(Felt::from(self.deploy_salt_base))

crates/cheatnet/tests/cheatcodes/deploy.rs

@@ -1,86 +1,16 @@
 use crate::common::assertions::{ClassHashAssert, assert_success};
 use crate::common::state::create_cached_state;
 use crate::common::{call_contract, deploy_at_wrapper, deploy_contract, get_contracts};
-use cairo_vm::vm::errors::hint_errors::HintError;
 use cheatnet::runtime_extensions::call_to_blockifier_runtime_extension::rpc::{
     CallFailure, CallResult,
 };
-use cheatnet::runtime_extensions::forge_runtime_extension::cheatcodes::CheatcodeError;
 use cheatnet::runtime_extensions::forge_runtime_extension::cheatcodes::declare::declare;
 use cheatnet::runtime_extensions::forge_runtime_extension::cheatcodes::storage::selector_from_name;
 use cheatnet::state::CheatnetState;
 use conversions::IntoConv;
-use runtime::EnhancedHintError;
 use starknet_api::core::ContractAddress;
 use starknet_types_core::felt::Felt;
 
-#[test]
-fn deploy_at_predefined_address() {
-    let mut cached_state = create_cached_state();
-    let mut cheatnet_state = CheatnetState::default();
-
-    let contracts_data = get_contracts();
-
-    let class_hash = declare(&mut cached_state, "HelloStarknet", &contracts_data)
-        .unwrap()
-        .unwrap_success();
-    let contract_address = deploy_at_wrapper(
-        &mut cached_state,
-        &mut cheatnet_state,
-        &class_hash,
-        &[],
-        ContractAddress::from(1_u8),
-    )
-    .unwrap();
-
-    assert_eq!(contract_address, ContractAddress::from(1_u8));
-
-    let selector = selector_from_name("get_balance");
-    let output = call_contract(
-        &mut cached_state,
-        &mut cheatnet_state,
-        &contract_address,
-        selector,
-        &[],
-    );
-
-    assert_success(output, &[Felt::from(0)]);
-}
-
-#[test]
-fn deploy_two_at_the_same_address() {
-    let mut cached_state = create_cached_state();
-    let mut cheatnet_state = CheatnetState::default();
-
-    let contracts_data = get_contracts();
-
-    let class_hash = declare(&mut cached_state, "HelloStarknet", &contracts_data)
-        .unwrap()
-        .unwrap_success();
-    deploy_at_wrapper(
-        &mut cached_state,
-        &mut cheatnet_state,
-        &class_hash,
-        &[],
-        ContractAddress::from(1_u8),
-    )
-    .unwrap();
-
-    let result = deploy_at_wrapper(
-        &mut cached_state,
-        &mut cheatnet_state,
-        &class_hash,
-        &[],
-        ContractAddress::from(1_u8),
-    );
-
-    assert!(matches!(
-        result,
-        Err(CheatcodeError::Unrecoverable(EnhancedHintError::Hint(HintError::CustomHint(err))))
-        if err.as_ref() == "Address is already taken"
-    ));
-}
-
 #[test]
 fn call_predefined_contract_from_proxy_contract() {
     let mut cached_state = create_cached_state();
@@ -95,6 +25,7 @@ fn call_predefined_contract_from_proxy_contract() {
     )
     .unwrap()
     .unwrap_success();
+
     let cheat_caller_address_checker_address = deploy_at_wrapper(
         &mut cached_state,
         &mut cheatnet_state,
@@ -182,31 +113,6 @@ fn deploy_contract_on_predefined_address_after_its_usage() {
     assert_success(output, &[]);
 }
 
-#[test]
-fn try_to_deploy_at_0() {
-    let mut cached_state = create_cached_state();
-    let mut cheatnet_state = CheatnetState::default();
-
-    let contracts_data = get_contracts();
-
-    let class_hash = declare(&mut cached_state, "HelloStarknet", &contracts_data)
-        .unwrap()
-        .unwrap_success();
-    let output = deploy_at_wrapper(
-        &mut cached_state,
-        &mut cheatnet_state,
-        &class_hash,
-        &[],
-        ContractAddress::from(0_u8),
-    );
-
-    assert!(match output {
-        Err(CheatcodeError::Unrecoverable(EnhancedHintError::Hint(HintError::CustomHint(msg)))) =>
-            msg.as_ref() == "Cannot deploy contract at address 0.",
-        _ => false,
-    });
-}
-
 #[test]
 fn deploy_invokes_constructor() {
     let mut cached_state = create_cached_state();

crates/forge/tests/data/contracts/panicking_constructor.cairo

@@ -111,42 +111,37 @@ fn deploy_two_at_the_same_address() {
     assert_case_output_contains(
         &result,
         "deploy_two_at_the_same_address",
-        "Address is already taken",
+        "Deployment failed: contract already deployed at address 0x000000000000000000000000000000000000000000000000000000000000007b",
     );
 }
 
 #[test]
-fn deploy_at_error_handling() {
+fn fail_to_deploy_at_0() {
     let test = test_case!(
         indoc!(
             r#"
-        use array::ArrayTrait;
         use snforge_std::{ declare, ContractClassTrait, DeclareResultTrait };
-        use starknet::ContractAddress;
 
         #[test]
-        fn deploy_at_error_handling() {
-            let contract_address = 123;
-
-            let contract = declare("PanickingConstructor").unwrap().contract_class();
-            match contract.deploy_at(@array![], contract_address.try_into().unwrap()) {
-                Result::Ok(_) => panic_with_felt252('shouldve panicked'),
-                Result::Err(panic_data) => {
-                    assert(*panic_data.at(0) == 'PANIK', 'wrong 1st panic datum');
-                    assert(*panic_data.at(1) == 'DEJTA', 'wrong 2nd panic datum');
-                },
-            }
+        fn deploy_at_0() {
+            let contract = declare("HelloStarknet").unwrap().contract_class();
+            contract.deploy_at(@array![], 0.try_into().unwrap()).unwrap();
         }
     "#
         ),
         Contract::from_code_path(
-            "PanickingConstructor".to_string(),
-            Path::new("tests/data/contracts/panicking_constructor.cairo"),
+            "HelloStarknet".to_string(),
+            Path::new("tests/data/contracts/hello_starknet.cairo"),
         )
         .unwrap()
     );
 
     let result = run_test_case(&test, ForgeTrackedResource::CairoSteps);
 
-    assert_passed(&result);
+    assert_failed(&result);
+    assert_case_output_contains(
+        &result,
+        "deploy_at_0",
+        "Cannot deploy contract at address 0",
+    );
 }

crates/forge/tests/integration/deploy_at.rs

@@ -78,10 +78,11 @@ impl ContractClassImpl of ContractClassTrait {
         constructor_calldata: @Array::<felt252>,
         contract_address: ContractAddress,
     ) -> SyscallResult<(ContractAddress, Span<felt252>)> {
-        let mut inputs = _prepare_calldata(self.class_hash, constructor_calldata);
-        inputs.append(contract_address.into());
+        execute_cheatcode_and_deserialize::<
+            'set_deploy_at_address', (),
+        >(array![contract_address.into()].span());
 
-        execute_cheatcode_and_deserialize::<'deploy_at'>(inputs.span())
+        self.deploy(constructor_calldata)
     }
 
     fn new<T, +Into<T, ClassHash>>(class_hash: T) -> ContractClass {

snforge_std/src/cheatcodes/contract_class.cairo

@@ -78,10 +78,11 @@ impl ContractClassImpl of ContractClassTrait {
         constructor_calldata: @Array::<felt252>,
         contract_address: ContractAddress,
     ) -> SyscallResult<(ContractAddress, Span<felt252>)> {
-        let mut inputs = _prepare_calldata(self.class_hash, constructor_calldata);
-        inputs.append(contract_address.into());
+        execute_cheatcode_and_deserialize::<
+            'set_deploy_at_address', (),
+        >(array![contract_address.into()].span());
 
-        execute_cheatcode_and_deserialize::<'deploy_at'>(inputs.span())
+        self.deploy(constructor_calldata)
     }
 
     fn new<T, +Into<T, ClassHash>>(class_hash: T) -> ContractClass {