Cheatcode for getting hash of the block

.gitignore

@@ -15,3 +15,4 @@ Scarb.lock
 snfoundry_trace/
 coverage/
 **/.forge_e2e_cache/
+

.tool-versions

@@ -1 +1 @@
-scarb 2.7.0
+scarb 2.7.0

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Forge
+
+#### Added
+
+- Cheatcode for getting block hash.
+
 ## [0.36.0] - 2025-01-15
 
 ### Forge

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

@@ -1,8 +1,24 @@
+use crate::abi::constants;
+use self::hint_processor::{
+    create_retdata_segment,
+    execute_inner_call,
+    execute_library_call,
+    felt_to_bool,
+    read_call_params,
+    read_calldata,
+    read_felt_array,
+    write_segment,
+    EmitEventError,
+    SyscallExecutionError,
+    SyscallHintProcessor,
+    BLOCK_NUMBER_OUT_OF_RANGE_ERROR,
+};
+
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::entry_point::execute_constructor_entry_point;
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::CheatnetState;
 use blockifier::execution::syscalls::hint_processor::SyscallHintProcessor;
 use blockifier::execution::syscalls::{
-    DeployRequest, DeployResponse, LibraryCallRequest, SyscallResponse, SyscallResult,
+    DeployRequest, DeployResponse, GetBlockHashRequest, GetBlockHashResponse, LibraryCallRequest, SyscallResponse, SyscallResult
 };
 use blockifier::execution::{call_info::CallInfo, entry_point::ConstructorContext};
 use blockifier::execution::{
@@ -57,6 +73,45 @@ pub fn get_execution_info_syscall(
     })
 }
 
+pub fn get_block_hash_syscall(
+    request: GetBlockHashRequest,
+    vm: &mut VirtualMachine,
+    syscall_handler: &mut SyscallHintProcessor<'_>,
+    cheatnet_state: &mut CheatnetState,
+    _remaining_gas: &mut u64,
+) -> SyscallResult<GetBlockHashResponse> {
+
+    // let execution_info_ptr = syscall_handler.get_or_allocate_execution_info_segment(vm)?;
+
+    // let cheated_data = cheatnet_state.get_cheated_data(syscall_handler.storage_address());
+
+    // let ptr_cheated_block_info = get_cheated_block_info_ptr(vm, execution_info_ptr, &cheated_data);
+
+    let cheated_block_number = cheatnet_state.block_info.block_number;
+
+    let requested_block_number = request.block_number;
+
+    if cheated_block_number < constants::STORED_BLOCK_HASH_BUFFER
+        || requested_block_number > cheated_block_number - constants::STORED_BLOCK_HASH_BUFFER
+    {
+        let out_of_range_error =
+            Felt::from_hex(BLOCK_NUMBER_OUT_OF_RANGE_ERROR).map_err(SyscallExecutionError::from)?;
+        return Err(SyscallExecutionError::SyscallError { error_data: vec![out_of_range_error] });
+    }
+
+    let key = StorageKey::try_from(Felt::from(requested_block_number))?;
+
+    let block_hash_contract_address =
+        ContractAddress::try_from(Felt::from(constants::BLOCK_HASH_CONTRACT_ADDRESS))?;
+
+    //should I get the contractAddress from the cheated block number? how do I do that?
+
+    let cheated_block_hash = BlockHash(syscall_handler.state.get_storage_at(block_hash_contract_address, key)?);
+
+    Ok(GetBlockHashResponse { block_hash: cheated_block_hash })
+
+}
+
 // blockifier/src/execution/syscalls/mod.rs:222 (deploy_syscall)
 pub fn deploy_syscall(
     request: DeployRequest,

crates/cheatnet/src/runtime_extensions/cheatable_starknet_runtime_extension.rs

@@ -78,6 +78,15 @@ impl<'a> ExtensionLogic for CheatableStarknetRuntimeExtension<'a> {
                 )
                 .map(|()| SyscallHandlingResult::Handled),
             _ => Ok(SyscallHandlingResult::Forwarded),
+            SyscallSelector::GetBlockHash => self
+                .execute_syscall(
+                    syscall_handler,
+                    vm,
+                    cheated_syscalls::get_block_hash_syscall,
+                    SyscallSelector::Deploy,
+                )
+                .map(|()| SyscallHandlingResult::Handled),
+            _ => Ok(SyscallHandlingResult::Forwarded),
         }
     }
 

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/cheatcodes/cheat_block_hash.rs

@@ -0,0 +1,66 @@
+use super::cheat_execution_info::{
+    BlockInfoMockOperations, CheatArguments, ExecutionInfoMockOperations, Operation,
+};
+use crate::state::CheatSpan;
+use crate::CheatnetState;
+use cairo_vm::Felt252;
+use starknet_api::core::ContractAddress;
+
+impl CheatnetState {
+    pub fn cheat_block_hash(
+        &mut self,
+        contract_address: ContractAddress,
+        block_hash: Felt252,
+        span: CheatSpan,
+    ) {
+        self.cheat_execution_info(ExecutionInfoMockOperations {
+            block_info: BlockInfoMockOperations {
+                block_hash: Operation::Start(CheatArguments {
+                    value: block_hash,
+                    span,
+                    target: contract_address,
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+    }
+
+    pub fn start_cheat_block_hash_global(&mut self, block_hash: Felt252) {
+        self.cheat_execution_info(ExecutionInfoMockOperations {
+            block_info: BlockInfoMockOperations {
+                block_hash: Operation::StartGlobal(block_hash),
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+    }
+
+    pub fn start_cheat_block_hash(
+        &mut self,
+        contract_address: ContractAddress,
+        block_hash: Felt252,
+    ) {
+        self.cheat_block_hash(contract_address, block_hash, CheatSpan::Indefinite);
+    }
+
+    pub fn stop_cheat_block_hash(&mut self, contract_address: ContractAddress) {
+        self.cheat_execution_info(ExecutionInfoMockOperations {
+            block_info: BlockInfoMockOperations {
+                block_hash: Operation::Stop(contract_address),
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+    }
+
+    pub fn stop_cheat_block_hash_global(&mut self) {
+        self.cheat_execution_info(ExecutionInfoMockOperations {
+            block_info: BlockInfoMockOperations {
+                block_hash: Operation::StopGlobal,
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+    }
+}

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/cheatcodes/cheat_execution_info.rs

@@ -178,4 +178,4 @@ impl CheatnetState {
 
         for_all_fields!(decrement!);
     }
-}
+}

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

@@ -3,6 +3,7 @@ use cairo_vm::vm::errors::hint_errors::HintError;
 use runtime::EnhancedHintError;
 use starknet_types_core::felt::Felt;
 
+pub mod cheat_block_hash;
 pub mod cheat_block_number;
 pub mod cheat_block_timestamp;
 pub mod cheat_caller_address;

crates/cheatnet/src/state.rs

@@ -427,6 +427,14 @@ impl CheatnetState {
         ContractAddressSalt(Felt::from(self.deploy_salt_base))
     }
 
+    // #[must_use]
+    // pub fn get_cheated_block_hash(&mut self, address: ContractAddress) -> Option<Felt> {
+    //     self.get_cheated_execution_info_for_contract(address)
+    //         .block_info
+    //         .block_hash
+    //         .as_value()
+    // } not sure about impl this one
+
     #[must_use]
     pub fn get_cheated_block_number(&mut self, address: ContractAddress) -> Option<u64> {
         self.get_cheated_execution_info_for_contract(address)