blockifier: add test_proving_gas_minus_sierra_gas_equals_builtin_gas

0.13.6

Author: avivg-starkware

crates/blockifier/src/bouncer_test.rs

@@ -2,14 +2,17 @@ use std::collections::{HashMap, HashSet};
 
 use assert_matches::assert_matches;
 use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use rstest::rstest;
+use starknet_api::core::ClassHash;
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::transaction::fields::Fee;
 use starknet_api::{class_hash, contract_address, storage_key};
 
 use super::BouncerConfig;
 use crate::blockifier::transaction_executor::TransactionExecutorError;
 use crate::bouncer::{
+    get_tx_weights,
     verify_tx_weights_within_max_capacity,
     Bouncer,
     BouncerWeights,
@@ -18,9 +21,12 @@ use crate::bouncer::{
 use crate::context::BlockContext;
 use crate::execution::call_info::ExecutionSummary;
 use crate::fee::resources::{ComputationResources, TransactionResources};
-use crate::state::cached_state::{StateChangesKeys, TransactionalState};
+use crate::state::cached_state::{StateChangesKeys, StateMaps, TransactionalState};
+use crate::test_utils::contracts::FeatureContract;
 use crate::test_utils::initial_test_state::test_state;
+use crate::test_utils::{CairoVersion, RunnableCairo1};
 use crate::transaction::errors::TransactionExecutionError;
+use crate::utils::{add_maps, u64_from_usize};
 
 #[test]
 fn test_block_weights_has_room() {
@@ -239,3 +245,139 @@ fn test_transaction_too_large_sierra_gas_based() {
         )
     )  if *max_capacity == bouncer_config.block_max_capacity && *tx_size == expected_weights);
 }
+
+/// Verifies that the difference between proving gas and Sierra gas
+/// is fully accounted for by the builtin gas delta (Stone vs Stwo).
+///
+/// Covers combinations of OS computation builtins and CASM hash computation builtins.
+#[rstest]
+#[case::no_os_no_casm(
+    &[],
+    ExecutionResources::default(),
+    HashSet::new(),
+    HashMap::new(),
+)]
+#[case::with_os_only(
+    &[],
+    ExecutionResources {
+        builtin_instance_counter: HashMap::from([
+            (BuiltinName::bitwise, 1),
+        ]),
+        ..Default::default()
+    },
+    HashSet::new(),
+    HashMap::new(),
+)]
+#[case::with_casm_only(
+    &[
+        (FeatureContract::TestContract(CairoVersion::Cairo0), 1),
+        (FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm)), 1),
+    ],
+    ExecutionResources::default(),
+    HashSet::from([
+        FeatureContract::TestContract(CairoVersion::Cairo0).get_class_hash(),
+        FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm)).get_class_hash(),
+    ]),
+    // Builtins mapping computed by printing `additional_os_resources.builtin_instance_counter`
+    // in `get_tx_weights` (bouncer_test.rs) for the above contracts.
+    HashMap::from([
+        (BuiltinName::poseidon, 11699),
+        (BuiltinName::pedersen, 2205),
+    ]),
+)]
+#[case::with_os_and_casm(
+    &[
+        (FeatureContract::TestContract(CairoVersion::Cairo0), 1),
+        (FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm)), 1),
+    ],
+    ExecutionResources {
+        builtin_instance_counter: HashMap::from([
+            (BuiltinName::range_check, 1),
+            (BuiltinName::bitwise, 2),
+        ]),
+        ..Default::default()
+    },
+    HashSet::from([
+        FeatureContract::TestContract(CairoVersion::Cairo0).get_class_hash(),
+        FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm)).get_class_hash(),
+    ]),
+    HashMap::from([
+        (BuiltinName::poseidon, 11699),
+        (BuiltinName::pedersen, 2205),
+    ]),
+)]
+fn test_proving_gas_minus_sierra_gas_equals_builtin_gas(
+    #[case] contract_instances: &[(FeatureContract, u16)],
+    #[case] os_vm_resources: ExecutionResources,
+    #[case] executed_class_hashes: HashSet<ClassHash>,
+    #[case] casm_hash_computation_builtins: HashMap<BuiltinName, usize>,
+) {
+    let block_context = BlockContext::create_for_account_testing();
+    let state = test_state(&block_context.chain_info, Fee(0), contract_instances);
+
+    // Transaction builtin counters.
+    let mut tx_builtin_counters =
+        HashMap::from([(BuiltinName::range_check, 2), (BuiltinName::pedersen, 1)]);
+
+    let tx_resources = TransactionResources {
+        computation: ComputationResources {
+            sierra_gas: GasAmount(100),
+            tx_vm_resources: ExecutionResources {
+                builtin_instance_counter: tx_builtin_counters.clone(),
+                ..Default::default()
+            },
+            os_vm_resources: os_vm_resources.clone(),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    // If we simulate CASM hash computation, we assume storage entries were visited.
+    let n_visited_storage_entries = if casm_hash_computation_builtins.is_empty() { 0 } else { 1 };
+
+    let result = get_tx_weights(
+        &state,
+        &executed_class_hashes,
+        n_visited_storage_entries,
+        &tx_resources,
+        &StateMaps::default().keys(), // state changes keys
+        &block_context.versioned_constants,
+        &tx_builtin_counters,
+        &block_context.bouncer_config.builtin_weights,
+    )
+    .unwrap();
+
+    // Combine TX + OS + CASM builtin usage.
+    add_maps(&mut tx_builtin_counters, &os_vm_resources.builtin_instance_counter);
+    add_maps(&mut tx_builtin_counters, &casm_hash_computation_builtins);
+
+    // Compute expected gas delta from builtin delta (Stwo - Stone).
+    let expected_builtin_gas_delta = tx_builtin_counters
+        .iter()
+        .map(|(name, count)| {
+            let swo_gas = block_context.bouncer_config.builtin_weights.builtin_weight(name);
+            let stone_gas = block_context
+                .versioned_constants
+                .os_constants
+                .gas_costs
+                .builtins
+                .get_builtin_gas_cost(name)
+                .expect();
+
+            let stwo_total = swo_gas.checked_mul(*count).map(u64_from_usize).expect("overflow");
+            let stone_total = u64_from_usize(*count).checked_mul(stone_gas).expect("overflow");
+
+            stwo_total.checked_sub(stone_total).expect("underflow")
+        })
+        // Sum the deltas.
+        .try_fold(0u64, |acc, val| acc.checked_add(val))
+        .expect("overflow in sum");
+
+    assert_eq!(
+        result.proving_gas.0 - result.sierra_gas.0,
+        expected_builtin_gas_delta,
+        "Proving gas: {} - Sierra gas: {} ≠ builtins gap: {}",
+        result.proving_gas.0,
+        result.sierra_gas.0,
+        expected_builtin_gas_delta
+    );
+}