Bump blockifier to 0.14.0 (#3416)

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

Towards #3174

**Stack**:
- #3417
- #3416 ⬅

## Introduced changes

Bump blockifier to v0.14.0

## 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`

Author: franciszekjob

Cargo.lock

@@ -29,22 +29,22 @@ license = "MIT"
 license-file = "LICENSE"
 
 [workspace.dependencies]
-blockifier = { git = "https://github.com/starkware-libs/sequencer.git", branch = "main-v0.13.6", default-features = false, features = ["testing", "tracing"] }
+blockifier = { version = "0.15.0-rc.2", features = ["testing", "tracing"]}
 bigdecimal = "0.4.8"
-starknet_api = { git = "https://github.com/starkware-libs/sequencer.git", branch = "main-v0.13.6" }
-cairo-lang-casm = { version = "2.11.2", features = ["serde"] }
-cairo-lang-sierra = "2.11.2"
-cairo-lang-utils = "2.11.2"
-cairo-lang-starknet = "2.11.2"
-cairo-lang-filesystem = "2.11.2"
-cairo-lang-diagnostics = "2.11.2"
-cairo-lang-sierra-type-size = "2.11.2"
-cairo-lang-syntax = "2.11.2"
-cairo-lang-test-plugin = "2.11.2"
-cairo-lang-starknet-classes = "2.11.2"
-cairo-lang-parser = "2.11.2"
-cairo-vm = "1.0.2"
-cairo-annotations = "0.4.0"
+starknet_api = "0.15.0-rc.2"
+cairo-lang-casm = { version = "2.12.0-rc.0", features = ["serde"] }
+cairo-lang-sierra = "2.12.0-rc.0"
+cairo-lang-utils = "2.12.0-rc.0"
+cairo-lang-starknet = "2.12.0-rc.0"
+cairo-lang-filesystem = "2.12.0-rc.0"
+cairo-lang-diagnostics = "2.12.0-rc.0"
+cairo-lang-sierra-type-size = "2.12.0-rc.0"
+cairo-lang-syntax = "2.12.0-rc.0"
+cairo-lang-test-plugin = "2.12.0-rc.0"
+cairo-lang-starknet-classes = "2.12.0-rc.0"
+cairo-lang-parser = "2.12.0-rc.0"
+cairo-vm = "2.2.0"
+cairo-annotations = "0.5.0-rc.0"
 dirs = "6.0.0"
 dialoguer = "0.11.0"
 starknet-types-core = { version = "0.1.7", features = ["hash", "prime-bigint"] }

Cargo.toml

@@ -5,8 +5,6 @@ use crate::predeployment::predeployed_contract::PredeployedContract;
 
 use super::constructor_data::ERC20ConstructorData;
 
-// use super::predeployed_contract::{ERC20ConstructorData, PredeployedContract};
-
 pub const ETH_CONTRACT_ADDRESS: &str =
     "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
 

crates/cheatnet/src/predeployment/erc20/eth.rs

@@ -11,7 +11,7 @@ use blockifier::execution::entry_point_execution::{
     ExecutionRunnerMode, VmExecutionContext, finalize_execution,
     initialize_execution_context_with_runner_mode, prepare_call_arguments,
 };
-use blockifier::execution::syscalls::hint_processor::SyscallUsageMap;
+use blockifier::execution::syscalls::vm_syscall_utils::SyscallUsageMap;
 use blockifier::{
     execution::{
         contract_class::EntryPointV1, entry_point::EntryPointExecutionContext,

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

@@ -5,30 +5,27 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 use blockifier::execution::syscalls::hint_processor::{
     SyscallExecutionError, SyscallHintProcessor,
 };
-use blockifier::execution::syscalls::{
-    DeployRequest, DeployResponse, GetBlockHashRequest, GetBlockHashResponse, LibraryCallRequest,
-    SyscallResponse, syscall_base::SyscallResult,
+use blockifier::execution::syscalls::syscall_base::SyscallResult;
+use blockifier::execution::syscalls::vm_syscall_utils::{
+    CallContractRequest, DeployRequest, DeployResponse, EmptyRequest, GetBlockHashRequest,
+    GetBlockHashResponse, GetExecutionInfoResponse, LibraryCallRequest, SyscallResponse,
+    SyscallSelector, WriteResponseResult,
 };
 use blockifier::execution::{call_info::CallInfo, entry_point::ConstructorContext};
 use blockifier::execution::{
-    execution_utils::ReadOnlySegment,
-    syscalls::{WriteResponseResult, hint_processor::write_segment},
+    execution_utils::ReadOnlySegment, syscalls::hint_processor::write_segment,
 };
 use blockifier::state::errors::StateError;
 use blockifier::{
-    execution::execution_utils::update_remaining_gas,
-    execution::syscalls::{CallContractRequest, hint_processor::create_retdata_segment},
-};
-use blockifier::{
-    execution::{
-        deprecated_syscalls::DeprecatedSyscallSelector,
-        entry_point::{
-            CallEntryPoint, CallType, EntryPointExecutionContext, EntryPointExecutionResult,
-        },
-        syscalls::{EmptyRequest, GetExecutionInfoResponse},
+    execution::entry_point::{
+        CallEntryPoint, CallType, EntryPointExecutionContext, EntryPointExecutionResult,
     },
     state::state_api::State,
 };
+use blockifier::{
+    execution::execution_utils::update_remaining_gas,
+    execution::syscalls::hint_processor::create_retdata_segment,
+};
 use cairo_vm::types::relocatable::Relocatable;
 use cairo_vm::vm::vm_core::VirtualMachine;
 use starknet_api::core::calculate_contract_address;
@@ -38,8 +35,6 @@ use starknet_api::{
     transaction::fields::Calldata,
 };
 
-pub type SyscallSelector = DeprecatedSyscallSelector;
-
 pub fn get_execution_info_syscall(
     _request: EmptyRequest,
     vm: &mut VirtualMachine,

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

@@ -14,7 +14,7 @@ use blockifier::execution::deprecated_entry_point_execution::{
 use blockifier::execution::entry_point::{EntryPointExecutionContext, ExecutableCallEntryPoint};
 use blockifier::execution::errors::EntryPointExecutionError;
 use blockifier::execution::execution_utils::Args;
-use blockifier::execution::syscalls::hint_processor::SyscallUsageMap;
+use blockifier::execution::syscalls::vm_syscall_utils::SyscallUsageMap;
 use blockifier::state::state_api::State;
 use cairo_vm::hint_processor::hint_processor_definition::HintProcessor;
 use cairo_vm::vm::runners::cairo_runner::{CairoArg, CairoRunner};

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/deprecated/cairo0_execution.rs

@@ -3,38 +3,43 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::rpc::{AddressOrClassHash, CallResult};
 use crate::runtime_extensions::call_to_blockifier_runtime_extension::CheatnetState;
 use crate::runtime_extensions::common::{get_relocated_vm_trace, get_syscalls_gas_consumed, sum_syscall_usage};
+use crate::state::CheatStatus;
+use blockifier::execution::call_info::{CallExecution, Retdata, StorageAccessTracker};
 use crate::runtime_extensions::forge_runtime_extension::{get_nested_calls_syscalls_sierra_gas, get_nested_calls_syscalls_vm_resources};
-use crate::state::{CheatStatus};
-use blockifier::execution::call_info::{CallExecution, Retdata};
 use blockifier::execution::contract_class::{RunnableCompiledClass, TrackedResource};
-use blockifier::execution::syscalls::hint_processor::{SyscallUsageMap, ENTRYPOINT_NOT_FOUND_ERROR, OUT_OF_GAS_ERROR};
+
+use blockifier::execution::entry_point::{EntryPointRevertInfo, ExecutableCallEntryPoint};
+use blockifier::execution::stack_trace::{
+    Cairo1RevertHeader, extract_trailing_cairo1_revert_trace,
+};
+use blockifier::execution::syscalls::hint_processor::{
+    ENTRYPOINT_NOT_FOUND_ERROR, OUT_OF_GAS_ERROR,
+};
+use blockifier::execution::syscalls::vm_syscall_utils::SyscallUsageMap;
 use blockifier::{
     execution::{
         call_info::CallInfo,
         entry_point::{
-            handle_empty_constructor, CallEntryPoint, CallType, ConstructorContext,
-            EntryPointExecutionContext, EntryPointExecutionResult,
-            FAULTY_CLASS_HASH,
+            CallEntryPoint, CallType, ConstructorContext, EntryPointExecutionContext,
+            EntryPointExecutionResult, FAULTY_CLASS_HASH, handle_empty_constructor,
         },
         errors::{EntryPointExecutionError, PreExecutionError},
     },
     state::state_api::State,
 };
 use cairo_vm::vm::runners::cairo_runner::{CairoRunner, ExecutionResources};
 use cairo_vm::vm::trace::trace_entry::RelocatedTraceEntry;
+use conversions::FromConv;
 use conversions::string::TryFromHexStr;
+use shared::vm::VirtualMachineExt;
 use starknet_api::{
     contract_class::EntryPointType,
     core::ClassHash,
-    transaction::{fields::Calldata, TransactionVersion},
+    transaction::{TransactionVersion, fields::Calldata},
 };
 use starknet_types_core::felt::Felt;
 use std::collections::{HashMap, HashSet};
-use blockifier::execution::entry_point::{EntryPointRevertInfo, ExecutableCallEntryPoint};
-use blockifier::execution::stack_trace::{extract_trailing_cairo1_revert_trace, Cairo1RevertHeader};
 use thiserror::Error;
-use conversions::FromConv;
-use shared::vm::VirtualMachineExt;
 
 pub(crate) type ContractClassEntryPointExecutionResult =
     Result<CallInfoWithExecutionData, EntryPointExecutionErrorWithTrace>;
@@ -444,12 +449,9 @@ fn mocked_call_info(
             gas_consumed: 0,
         },
         resources: ExecutionResources::default(),
-        inner_calls: vec![],
-        storage_read_values: vec![],
-        accessed_storage_keys: HashSet::new(),
-        read_class_hash_values: vec![],
         tracked_resource,
-        accessed_contract_addresses: HashSet::default(),
+        inner_calls: vec![],
+        storage_access_tracker: StorageAccessTracker::default(),
         builtin_counters: HashMap::default(),
     }
 }

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

@@ -2,16 +2,14 @@ use std::marker::PhantomData;
 
 use blockifier::execution::entry_point::{CallEntryPoint, CallType};
 use blockifier::execution::execution_utils::felt_from_ptr;
-use blockifier::execution::syscalls::{
-    CallContractRequest, LibraryCallRequest, SyscallRequestWrapper,
+use blockifier::execution::syscalls::hint_processor::SyscallHintProcessor;
+use blockifier::execution::syscalls::syscall_executor::SyscallExecutor;
+use blockifier::execution::syscalls::vm_syscall_utils::{
+    CallContractRequest, LibraryCallRequest, RevertData, SyscallRequestWrapper, SyscallSelector,
 };
 use blockifier::execution::{
-    deprecated_syscalls::DeprecatedSyscallSelector,
     execution_utils::ReadOnlySegment,
-    syscalls::{
-        SyscallRequest, SyscallResponse, SyscallResponseWrapper,
-        hint_processor::SyscallHintProcessor,
-    },
+    syscalls::vm_syscall_utils::{SyscallRequest, SyscallResponse, SyscallResponseWrapper},
 };
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
@@ -48,7 +46,7 @@ impl<'a> ExtensionLogic for CallToBlockifierExtension<'a> {
 
     fn override_system_call(
         &mut self,
-        selector: DeprecatedSyscallSelector,
+        selector: SyscallSelector,
         vm: &mut VirtualMachine,
         extended_runtime: &mut Self::Runtime,
     ) -> Result<SyscallHandlingResult, HintError> {
@@ -58,7 +56,7 @@ impl<'a> ExtensionLogic for CallToBlockifierExtension<'a> {
             // and to enable handling call errors with safe dispatchers in the test code
             // since call errors cannot be handled on real starknet
             // https://docs.starknet.io/architecture-and-concepts/smart-contracts/system-calls-cairo1/#call_contract
-            DeprecatedSyscallSelector::CallContract => {
+            SyscallSelector::CallContract => {
                 execute_syscall::<CallContractRequest>(vm, extended_runtime)?;
 
                 extended_runtime
@@ -68,7 +66,7 @@ impl<'a> ExtensionLogic for CallToBlockifierExtension<'a> {
 
                 Ok(SyscallHandlingResult::Handled)
             }
-            DeprecatedSyscallSelector::LibraryCall => {
+            SyscallSelector::LibraryCall => {
                 execute_syscall::<LibraryCallRequest>(vm, extended_runtime)?;
 
                 extended_runtime
@@ -204,7 +202,7 @@ fn write_call_response(
         CallResult::Failure(failure_type) => match failure_type {
             CallFailure::Panic { panic_data } => SyscallResponseWrapper::Failure {
                 gas_counter,
-                error_data: panic_data,
+                revert_data: RevertData::new_normal(panic_data),
             },
             CallFailure::Error { msg } => {
                 return Err(HintError::CustomHint(Box::from(msg.to_string())));

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

@@ -5,12 +5,14 @@ use crate::runtime_extensions::{
     },
     common::create_execute_calldata,
 };
-use blockifier::execution::entry_point::CallEntryPoint;
 use blockifier::execution::{
     call_info::CallInfo,
     entry_point::{CallType, EntryPointExecutionResult},
     errors::{EntryPointExecutionError, PreExecutionError},
-    syscalls::hint_processor::{SyscallHintProcessor, SyscallUsageMap},
+    syscalls::hint_processor::SyscallHintProcessor,
+};
+use blockifier::execution::{
+    entry_point::CallEntryPoint, syscalls::vm_syscall_utils::SyscallUsageMap,
 };
 use blockifier::state::errors::StateError;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;

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

@@ -3,19 +3,20 @@ use crate::runtime_extensions::call_to_blockifier_runtime_extension::execution::
 };
 use crate::state::CheatnetState;
 use anyhow::Result;
+use blockifier::blockifier_versioned_constants::SyscallGasCost;
 use blockifier::execution::entry_point::EntryPointExecutionContext;
 use blockifier::execution::syscalls::hint_processor::OUT_OF_GAS_ERROR;
-use blockifier::execution::syscalls::{
-    SyscallRequest, SyscallRequestWrapper, SyscallResponse, SyscallResponseWrapper,
-    syscall_base::SyscallResult,
+use blockifier::execution::syscalls::syscall_base::SyscallResult;
+use blockifier::execution::syscalls::syscall_executor::SyscallExecutor;
+use blockifier::execution::syscalls::vm_syscall_utils::{
+    RevertData, SyscallRequest, SyscallRequestWrapper, SyscallResponse, SyscallResponseWrapper,
+    SyscallSelector,
 };
 use blockifier::execution::{
     common_hints::HintExecutionResult,
-    deprecated_syscalls::DeprecatedSyscallSelector,
     syscalls::hint_processor::{SyscallExecutionError, SyscallHintProcessor},
 };
 use blockifier::utils::u64_from_usize;
-use blockifier::versioned_constants::SyscallGasCost;
 use cairo_vm::{
     types::relocatable::Relocatable,
     vm::{
@@ -27,8 +28,6 @@ use conversions::string::TryFromHexStr;
 use runtime::{ExtendedRuntime, ExtensionLogic, StarknetRuntime, SyscallHandlingResult};
 use starknet_types_core::felt::Felt;
 
-pub type SyscallSelector = DeprecatedSyscallSelector;
-
 pub struct CheatableStarknetRuntimeExtension<'a> {
     pub cheatnet_state: &'a mut CheatnetState,
 }
@@ -40,7 +39,7 @@ impl<'a> ExtensionLogic for CheatableStarknetRuntimeExtension<'a> {
 
     fn override_system_call(
         &mut self,
-        selector: DeprecatedSyscallSelector,
+        selector: SyscallSelector,
         vm: &mut VirtualMachine,
         extended_runtime: &mut Self::Runtime,
     ) -> Result<SyscallHandlingResult, HintError> {
@@ -94,7 +93,7 @@ impl<'a> ExtensionLogic for CheatableStarknetRuntimeExtension<'a> {
 
     fn handle_system_call_signal(
         &mut self,
-        selector: DeprecatedSyscallSelector,
+        selector: SyscallSelector,
         _vm: &mut VirtualMachine,
         extended_runtime: &mut Self::Runtime,
     ) {
@@ -187,11 +186,11 @@ impl CheatableStarknetRuntimeExtension<'_> {
 
         if gas_counter < required_gas {
             //  Out of gas failure.
-            let out_of_gas_error = TryFromHexStr::try_from_hex_str(OUT_OF_GAS_ERROR)
-                .map_err(SyscallExecutionError::from)?;
+            let out_of_gas_error =
+                Felt::try_from_hex_str(OUT_OF_GAS_ERROR).map_err(SyscallExecutionError::from)?;
             let response: SyscallResponseWrapper<Response> = SyscallResponseWrapper::Failure {
                 gas_counter,
-                error_data: vec![out_of_gas_error],
+                revert_data: RevertData::new_normal(vec![out_of_gas_error]),
             };
             response.write(vm, &mut syscall_handler.syscall_ptr)?;
 
@@ -215,7 +214,7 @@ impl CheatableStarknetRuntimeExtension<'_> {
             Err(SyscallExecutionError::Revert { error_data: data }) => {
                 SyscallResponseWrapper::Failure {
                     gas_counter: remaining_gas,
-                    error_data: data,
+                    revert_data: RevertData::new_normal(data),
                 }
             }
             Err(error) => return Err(error.into()),