chore(blockifier): remove syscall_gas_costs from os_constans

crates/blockifier/resources/versioned_constants_0_13_3.json

@@ -655,4 +655,4 @@
             10000
         ]
     }
-}
+}

crates/blockifier/resources/versioned_constants_0_13_4.json

@@ -116,115 +116,7 @@
             "validate_block_number_rounding": 100,
             "validate_timestamp_rounding": 3600
         },
-        "validated": "VALID",
-        "syscall_gas_costs": {
-            "call_contract": {
-                "entry_point_initial_budget": 1,
-                "step_gas_cost": 860,
-                "range_check": 15
-            },
-            "deploy": {
-                "entry_point_initial_budget": 1,
-                "step_gas_cost": 1128,
-                "range_check": 18,
-                "pedersen": 7
-            },
-            "emit_event": {
-                "step_gas_cost": 100,
-                "range_check": 1
-            },
-            "get_block_hash": {
-                "step_gas_cost": 104,
-                "range_check": 2
-            },
-            "get_execution_info": {
-                "step_gas_cost": 100,
-                "range_check": 1
-            },
-            "keccak": {
-                "syscall_base_gas_cost": 1
-            },
-            "keccak_round_cost": 180000,
-            "library_call": {
-                "entry_point_initial_budget": 1,
-                "step_gas_cost": 836,
-                "range_check": 15
-            },
-            "sha256_process_block": {
-                "step_gas_cost": 1855,
-                "range_check": 65,
-                "bitwise": 1115,
-                "syscall_base_gas_cost": 1
-            },
-            "replace_class": {
-                "step_gas_cost": 104,
-                "range_check": 1
-            },
-            "secp256k1_add": {
-                "range_check": 29,
-                "step_gas_cost": 410
-            },
-            "secp256k1_get_point_from_x": {
-                "memory_hole_gas_cost": 20,
-                "range_check": 30,
-                "step_gas_cost": 395
-            },
-            "secp256k1_get_xy": {
-                "memory_hole_gas_cost": 40,
-                "range_check": 11,
-                "step_gas_cost": 207
-            },
-            "secp256k1_mul": {
-                "memory_hole_gas_cost": 2,
-                "range_check": 7045,
-                "step_gas_cost": 76505
-            },
-            "secp256k1_new": {
-                "memory_hole_gas_cost": 40,
-                "range_check": 35,
-                "step_gas_cost": 461
-            },
-            "secp256r1_add": {
-                "range_check": 57,
-                "step_gas_cost": 593
-            },
-            "secp256r1_get_point_from_x": {
-                "memory_hole_gas_cost": 20,
-                "range_check": 44,
-                "step_gas_cost": 514
-            },
-            "secp256r1_get_xy": {
-                "memory_hole_gas_cost": 40,
-                "range_check": 11,
-                "step_gas_cost": 209
-            },
-            "secp256r1_mul": {
-                "memory_hole_gas_cost": 2,
-                "range_check": 13961,
-                "step_gas_cost": 125344
-            },
-            "secp256r1_new": {
-                "memory_hole_gas_cost": 40,
-                "range_check": 49,
-                "step_gas_cost": 580
-            },
-            "send_message_to_l1": {
-                "step_gas_cost": 141,
-                "range_check": 1
-            },
-            "storage_read": {
-                "step_gas_cost": 100,
-                "range_check": 1
-            },
-            "storage_write": {
-                "step_gas_cost": 100,
-                "range_check": 1
-            },
-            "get_class_hash_at": {
-                "step_gas_cost": 100,
-                "range_check": 1
-            }
-        }
+        "validated": "VALID"
     },
     "os_resources": {
         "execute_syscalls": {
@@ -320,7 +212,12 @@
                 "n_memory_holes": 0
             },
             "Keccak": {
-                "n_steps": 381,
+                "n_steps": 100,
+                "builtin_instance_counter": {},
+                "n_memory_holes": 0
+            },
+            "KeccakRound": {
+                "n_steps": 371,
                 "builtin_instance_counter": {
                     "bitwise_builtin": 6,
                     "keccak_builtin": 1,
@@ -661,4 +558,4 @@
             10000
         ]
     }
-}
+}

crates/blockifier/src/execution/deprecated_syscalls/mod.rs

@@ -64,6 +64,7 @@ pub enum DeprecatedSyscallSelector {
     GetTxInfo,
     GetTxSignature,
     Keccak,
+    KeccakRound,
     Sha256ProcessBlock,
     LibraryCall,
     LibraryCallL1Handler,

crates/blockifier/src/execution/syscalls/syscall_tests/constants.rs

@@ -1,4 +1,5 @@
-pub const REQUIRED_GAS_CALL_CONTRACT_TEST: u64 = 120370;
-pub const REQUIRED_GAS_STORAGE_READ_WRITE_TEST: u64 = 16990;
-pub const REQUIRED_GAS_GET_CLASS_HASH_AT_TEST: u64 = 7830;
-pub const REQUIRED_GAS_LIBRARY_CALL_TEST: u64 = 117970;
+pub const REQUIRED_GAS_CALL_CONTRACT_TEST: u64 = 110830;
+pub const REQUIRED_GAS_STORAGE_READ_WRITE_TEST: u64 = 16850;
+pub const REQUIRED_GAS_GET_CLASS_HASH_AT_TEST: u64 = 7760;
+pub const REQUIRED_GAS_LIBRARY_CALL_TEST: u64 = 108430;
+pub const REQUIRED_GAS_GET_BLOCK_HASH_TEST: u64 = 5220;

crates/blockifier/src/execution/syscalls/syscall_tests/deploy.rs

@@ -43,7 +43,7 @@ fn no_constructor(runnable_version: RunnableCairo1) {
     let deploy_call = &entry_point_call.execute_directly(&mut state).unwrap();
     assert_eq!(
         deploy_call.execution,
-        CallExecution { retdata: retdata![], gas_consumed: 155200, ..CallExecution::default() }
+        CallExecution { retdata: retdata![], gas_consumed: 145600, ..CallExecution::default() }
     );
 
     let deployed_contract_address = calculate_contract_address(
@@ -124,7 +124,7 @@ fn with_constructor(runnable_version: RunnableCairo1) {
     let deploy_call = &entry_point_call.execute_directly(&mut state).unwrap();
     assert_eq!(
         deploy_call.execution,
-        CallExecution { retdata: retdata![], gas_consumed: 164550, ..CallExecution::default() }
+        CallExecution { retdata: retdata![], gas_consumed: 154880, ..CallExecution::default() }
     );
 
     let constructor_call = &deploy_call.inner_calls[0];
@@ -136,7 +136,7 @@ fn with_constructor(runnable_version: RunnableCairo1) {
             // The test contract constructor returns its first argument.
             retdata: retdata![constructor_calldata[0]],
             // This reflects the gas cost of storage write syscall.
-            gas_consumed: 4610,
+            gas_consumed: 4540,
             ..CallExecution::default()
         }
     );

crates/blockifier/src/execution/syscalls/syscall_tests/emit_event.rs

@@ -41,7 +41,7 @@ fn positive_flow(runnable_version: RunnableCairo1) {
         call_info.execution,
         CallExecution {
             events: vec![OrderedEvent { order: 0, event }],
-            gas_consumed: 47330,
+            gas_consumed: 47260,
             ..Default::default()
         }
     );

crates/blockifier/src/execution/syscalls/syscall_tests/get_block_hash.rs

@@ -11,6 +11,7 @@ use crate::abi::constants;
 use crate::context::ChainInfo;
 use crate::execution::call_info::CallExecution;
 use crate::execution::entry_point::CallEntryPoint;
+use crate::execution::syscalls::syscall_tests::constants::REQUIRED_GAS_GET_BLOCK_HASH_TEST;
 use crate::retdata;
 use crate::state::cached_state::CachedState;
 use crate::state::state_api::State;
@@ -20,7 +21,9 @@ use crate::test_utils::initial_test_state::test_state;
 use crate::test_utils::{trivial_external_entry_point_new, CairoVersion, RunnableCairo1, BALANCE};
 use crate::versioned_constants::VersionedConstants;
 
-fn initialize_state(test_contract: FeatureContract) -> (CachedState<DictStateReader>, Felt, Felt) {
+pub fn initialize_state(
+    test_contract: FeatureContract,
+) -> (CachedState<DictStateReader>, Felt, Felt) {
     let chain_info = &ChainInfo::create_for_testing();
     let mut state = test_state(chain_info, BALANCE, &[(test_contract, 1)]);
 
@@ -53,7 +56,10 @@ fn positive_flow(runnable_version: RunnableCairo1) {
 
     assert_eq!(
         entry_point_call.clone().execute_directly(&mut state).unwrap().execution,
-        CallExecution { gas_consumed: 5220, ..CallExecution::from_retdata(retdata![block_hash]) }
+        CallExecution {
+            gas_consumed: REQUIRED_GAS_GET_BLOCK_HASH_TEST,
+            ..CallExecution::from_retdata(retdata![block_hash])
+        }
     );
 }
 

crates/blockifier/src/execution/syscalls/syscall_tests/keccak.rs

@@ -26,6 +26,6 @@ fn test_keccak(runnable_version: RunnableCairo1) {
 
     pretty_assertions::assert_eq!(
         entry_point_call.execute_directly(&mut state).unwrap().execution,
-        CallExecution { gas_consumed: 254240, ..CallExecution::from_retdata(retdata![]) }
+        CallExecution { gas_consumed: 254947, ..CallExecution::from_retdata(retdata![]) }
     );
 }

crates/blockifier/src/execution/syscalls/syscall_tests/library_call.rs

@@ -84,7 +84,7 @@ fn test_library_call_assert_fails(runnable_version: RunnableCairo1) {
                 // 'ENTRYPOINT_FAILED'.
                 felt!("0x454e545259504f494e545f4641494c4544")
             ]),
-            gas_consumed: 100980,
+            gas_consumed: 91580,
             failed: true,
             ..Default::default()
         }
@@ -124,7 +124,7 @@ fn test_nested_library_call(runnable_version: RunnableCairo1) {
         class_hash: Some(test_class_hash),
         code_address: None,
         call_type: CallType::Delegate,
-        initial_gas: 9999085960,
+        initial_gas: 9999104760,
         ..trivial_external_entry_point_new(test_contract)
     };
     let library_entry_point = CallEntryPoint {
@@ -139,16 +139,16 @@ fn test_nested_library_call(runnable_version: RunnableCairo1) {
         class_hash: Some(test_class_hash),
         code_address: None,
         call_type: CallType::Delegate,
-        initial_gas: 9999186940,
+        initial_gas: 9999196340,
         ..trivial_external_entry_point_new(test_contract)
     };
     let storage_entry_point = CallEntryPoint {
         calldata: calldata![felt!(key), felt!(value)],
-        initial_gas: 9998984320,
+        initial_gas: 9999012660,
         ..nested_storage_entry_point
     };
 
-    let storage_entry_point_gas = GasAmount(16990);
+    let storage_entry_point_gas = GasAmount(16850);
 
     // The default VersionedConstants is used in the execute_directly call bellow.
     let tracked_resource = test_contract.get_runnable_class().tracked_resource(
@@ -177,7 +177,7 @@ fn test_nested_library_call(runnable_version: RunnableCairo1) {
             gas_consumed: REQUIRED_GAS_LIBRARY_CALL_TEST,
             ..CallExecution::default()
         },
-        charged_resources: ChargedResources::from_gas(GasAmount(117970)),
+        charged_resources: ChargedResources::from_gas(GasAmount(108430)),
         inner_calls: vec![nested_storage_call_info],
         tracked_resource,
         ..Default::default()
@@ -197,7 +197,7 @@ fn test_nested_library_call(runnable_version: RunnableCairo1) {
         ..Default::default()
     };
 
-    let main_gas_consumed = 325110;
+    let main_gas_consumed = 296630;
     let expected_call_info = CallInfo {
         call: main_entry_point.clone(),
         execution: CallExecution {

crates/blockifier/src/execution/syscalls/syscall_tests/out_of_gas.rs

@@ -3,38 +3,50 @@ use starknet_api::{calldata, felt};
 use test_case::test_case;
 
 use crate::abi::constants::MAX_POSSIBLE_SIERRA_GAS;
+#[cfg(feature = "cairo_native")]
 use crate::context::ChainInfo;
 use crate::execution::call_info::CallExecution;
 use crate::execution::entry_point::CallEntryPoint;
-use crate::execution::syscalls::syscall_tests::constants::REQUIRED_GAS_STORAGE_READ_WRITE_TEST;
+use crate::execution::syscalls::syscall_tests::constants;
+use crate::execution::syscalls::syscall_tests::get_block_hash::initialize_state;
+use crate::execution::syscalls::SyscallSelector;
 use crate::retdata;
 use crate::test_utils::contracts::FeatureContract;
+#[cfg(feature = "cairo_native")]
 use crate::test_utils::initial_test_state::test_state;
-use crate::test_utils::{trivial_external_entry_point_new, CairoVersion, RunnableCairo1, BALANCE};
+#[cfg(feature = "cairo_native")]
+use crate::test_utils::BALANCE;
+use crate::test_utils::{trivial_external_entry_point_new, CairoVersion, RunnableCairo1};
 use crate::versioned_constants::VersionedConstants;
 
 #[cfg_attr(feature = "cairo_native", test_case(RunnableCairo1::Native; "Native"))]
 #[test_case(RunnableCairo1::Casm; "VM")]
 fn test_out_of_gas(runnable_version: RunnableCairo1) {
     let test_contract = FeatureContract::TestContract(CairoVersion::Cairo1(runnable_version));
-    let mut state = test_state(&ChainInfo::create_for_testing(), BALANCE, &[(test_contract, 1)]);
+    let (mut state, block_number, _block_hash) = initialize_state(test_contract);
 
-    let key = felt!(1234_u16);
-    let value = felt!(18_u8);
-    let calldata = calldata![key, value];
+    let calldata = calldata![block_number];
     let entry_point_call = CallEntryPoint {
+        entry_point_selector: selector_from_name("test_get_block_hash"),
         calldata,
-        entry_point_selector: selector_from_name("test_storage_read_write"),
-        initial_gas: REQUIRED_GAS_STORAGE_READ_WRITE_TEST - 1,
+        initial_gas: constants::REQUIRED_GAS_GET_BLOCK_HASH_TEST - 1,
         ..trivial_external_entry_point_new(test_contract)
     };
-    let call_info = entry_point_call.execute_directly(&mut state).unwrap();
+
+    let gas_costs = &VersionedConstants::create_for_testing().os_constants.gas_costs;
+    let get_block_hash_gas_cost =
+        gas_costs.syscalls.get_syscall_gas_cost(&SyscallSelector::GetBlockHash).unwrap();
+    let syscall_base_gas_cost = gas_costs.base.get_base_gas_cost("syscall_base_gas_cost");
+
+    // We hit the out of gas error right before executing the syscall.
+    let syscall_required_gas = get_block_hash_gas_cost - syscall_base_gas_cost;
+    let call_info = entry_point_call.clone().execute_directly(&mut state).unwrap();
     assert_eq!(
         call_info.execution,
         CallExecution {
             // 'Out of gas'
             retdata: retdata![felt!["0x4f7574206f6620676173"]],
-            gas_consumed: REQUIRED_GAS_STORAGE_READ_WRITE_TEST - 70,
+            gas_consumed: constants::REQUIRED_GAS_GET_BLOCK_HASH_TEST - syscall_required_gas,
             failed: true,
             ..Default::default()
         }

crates/blockifier/src/execution/syscalls/syscall_tests/secp.rs

@@ -25,7 +25,7 @@ fn test_secp256k1(runnable_version: RunnableCairo1) {
 
     pretty_assertions::assert_eq!(
         entry_point_call.execute_directly(&mut state).unwrap().execution,
-        CallExecution { gas_consumed: 17033486, ..Default::default() }
+        CallExecution { gas_consumed: 17031553, ..Default::default() }
     );
 }
 
@@ -45,6 +45,6 @@ fn test_secp256r1(runnable_version: RunnableCairo1) {
 
     pretty_assertions::assert_eq!(
         entry_point_call.execute_directly(&mut state).unwrap().execution,
-        CallExecution { gas_consumed: 27562930, ..Default::default() }
+        CallExecution { gas_consumed: 27560090, ..Default::default() }
     );
 }

crates/blockifier/src/execution/syscalls/syscall_tests/sha256.rs

@@ -26,6 +26,6 @@ fn test_sha256(runnable_version: RunnableCairo1) {
 
     pretty_assertions::assert_eq!(
         entry_point_call.execute_directly(&mut state).unwrap().execution,
-        CallExecution { gas_consumed: 881425, ..CallExecution::from_retdata(retdata![]) }
+        CallExecution { gas_consumed: 872425, ..CallExecution::from_retdata(retdata![]) }
     );
 }