Fix wrong caller address bug (#870)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #868

## Introduced changes

<!-- A brief description of the changes -->

- Correct caller address in constructor and called contract

## Breaking changes

<!-- List of all breaking changes, if applicable -->

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+### Forge
+
+#### Fixed
+- incorrect caller address bug
+
 ## [0.8.1] - 2023-10-12
 ### Forge
 

crates/cheatnet/src/cheatcodes/deploy.rs

@@ -1,4 +1,4 @@
-use crate::constants as crate_constants;
+use crate::constants::TEST_ADDRESS;
 use crate::constants::{build_block_context, build_transaction_context};
 use crate::state::BlockifierState;
 use crate::CheatnetState;
@@ -13,8 +13,10 @@ use std::sync::Arc;
 use blockifier::state::state_api::State;
 use cairo_felt::Felt252;
 use cairo_vm::vm::errors::hint_errors::HintError::CustomHint;
-use conversions::StarknetConversions;
 use num_traits::ToPrimitive;
+use starknet_api::core::PatriciaKey;
+use starknet_api::hash::StarkHash;
+use starknet_api::patricia_key;
 
 use crate::cheatcodes::EnhancedHintError;
 use crate::execution::syscalls::execute_deployment;
@@ -59,17 +61,14 @@ pub fn deploy_at(
         class_hash: *class_hash,
         code_address: Some(contract_address),
         storage_address: contract_address,
-        caller_address: crate_constants::TEST_ADDRESS
-            .to_string()
-            .to_contract_address(),
+        caller_address: ContractAddress(patricia_key!(TEST_ADDRESS)),
     };
 
     let calldata = Calldata(Arc::new(
         calldata.to_vec().iter().map(felt_to_stark_felt).collect(),
     ));
 
     let resources = &mut ExecutionResources::default();
-
     let result = execute_deployment(
         blockifier_state_raw,
         resources,

crates/cheatnet/src/rpc.rs

@@ -2,6 +2,7 @@ use anyhow::Result;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use crate::constants::TEST_ADDRESS;
 use crate::panic_data::try_extract_panic_data;
 use crate::state::BlockifierState;
 use crate::{
@@ -18,6 +19,8 @@ use blockifier::execution::{
 use blockifier::state::errors::StateError;
 use cairo_felt::Felt252;
 use cairo_lang_runner::short_string::as_cairo_short_string;
+use starknet_api::core::PatriciaKey;
+use starknet_api::patricia_key;
 use starknet_api::{
     core::{ContractAddress, EntryPointSelector},
     deprecated_contract_class::EntryPointType,
@@ -219,7 +222,8 @@ pub fn call_entry_point(
         entry_point_selector,
         calldata,
         storage_address: *contract_address,
-        caller_address: ContractAddress::default(),
+        // test_contract address
+        caller_address: ContractAddress(patricia_key!(TEST_ADDRESS)),
         call_type: CallType::Call,
         initial_gas: u64::MAX,
     };

crates/forge/tests/integration/test_state.rs

@@ -654,3 +654,91 @@ fn test_inconsistent_syscall_pointers() {
 
     assert_passed!(result);
 }
+
+#[test]
+fn test_caller_address_in_called_contract() {
+    let test = test_case!(
+        indoc!(
+            r#"
+        use result::ResultTrait;
+        use array::ArrayTrait;
+        use option::OptionTrait;
+        use traits::TryInto;
+        use starknet::ContractAddress;
+        use starknet::Felt252TryIntoContractAddress;
+        use snforge_std::{ declare, ContractClassTrait, test_address };
+
+        #[starknet::interface]
+        trait IPrankChecker<TContractState> {
+            fn get_caller_address(ref self: TContractState) -> felt252;
+        }
+
+        #[starknet::interface]
+        trait IConstructorPrankChecker<TContractState> {
+            fn get_stored_caller_address(ref self: TContractState) -> ContractAddress;
+        }
+
+        #[test]
+        fn test_contract() {
+            let prank_checker = declare('PrankChecker');
+            let contract_address_prank_checker = prank_checker.deploy(@ArrayTrait::new()).unwrap();
+            let dispatcher_prank_checker = IPrankCheckerDispatcher { contract_address: contract_address_prank_checker };
+
+            assert(dispatcher_prank_checker.get_caller_address() == test_address().into(), 'Incorrect caller address');
+
+
+            let constructor_prank_checker = declare('ConstructorPrankChecker');
+            let contract_address_constructor_prank_checker = constructor_prank_checker.deploy(@ArrayTrait::new()).unwrap();
+            let dispatcher_constructor_prank_checker = IConstructorPrankCheckerDispatcher { contract_address: contract_address_constructor_prank_checker };
+
+            assert(dispatcher_constructor_prank_checker.get_stored_caller_address() == test_address(), 'Incorrect caller address');
+
+        }
+    "#
+        ),
+        Contract::from_code_path(
+            "PrankChecker".to_string(),
+            Path::new("tests/data/contracts/prank_checker.cairo"),
+        )
+        .unwrap(),
+        Contract::new(
+            "ConstructorPrankChecker",
+            indoc!(
+                r#"
+            use starknet::ContractAddress;
+
+            #[starknet::interface]
+            trait IConstructorPrankChecker<TContractState> {
+                fn get_stored_caller_address(ref self: TContractState) -> ContractAddress;
+            }
+
+            #[starknet::contract]
+            mod ConstructorPrankChecker {
+                use starknet::ContractAddress;
+
+                #[storage]
+                struct Storage {
+                    caller_address: ContractAddress,
+                }
+
+                #[constructor]
+                fn constructor(ref self: ContractState) {
+                    let address = starknet::get_caller_address();
+                    self.caller_address.write(address);
+                }
+
+                #[external(v0)]
+                impl IConstructorPrankChecker of super::IConstructorPrankChecker<ContractState> {
+                    fn get_stored_caller_address(ref self: ContractState) -> ContractAddress {
+                        self.caller_address.read()
+                    }
+                }
+            }
+        "#
+            )
+        )
+    );
+    let result = run_test_case(&test);
+
+    assert_passed!(result);
+}