blockifier: test proof facts verifications

Author: meship-starkware

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -17,7 +17,7 @@ use starknet_api::abi::abi_utils::{
     get_storage_var_address,
     selector_from_name,
 };
-use starknet_api::block::{FeeType, GasPrice};
+use starknet_api::block::{BlockHash, BlockNumber, FeeType, GasPrice};
 use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
 use starknet_api::contract_class::ContractClass;
 use starknet_api::core::{
@@ -41,6 +41,7 @@ use starknet_api::test_utils::deploy_account::executable_deploy_account_tx;
 use starknet_api::test_utils::invoke::{executable_invoke_tx, InvokeTxArgs};
 use starknet_api::test_utils::{
     NonceManager,
+    CURRENT_BLOCK_NUMBER,
     DEFAULT_L1_DATA_GAS_MAX_AMOUNT,
     DEFAULT_L1_GAS_AMOUNT,
     DEFAULT_L2_GAS_MAX_AMOUNT,
@@ -58,7 +59,9 @@ use starknet_api::transaction::fields::{
     ProofFacts,
     Resource,
     ResourceBounds,
+    SnosProofFacts,
     ValidResourceBounds,
+    VIRTUAL_SNOS,
 };
 use starknet_api::transaction::{
     DeclareTransaction,
@@ -80,6 +83,7 @@ use starknet_api::{
 };
 use starknet_types_core::felt::Felt;
 
+use crate::abi::constants::STORED_BLOCK_HASH_BUFFER;
 use crate::context::{BlockContext, TransactionContext};
 use crate::execution::call_info::CallInfo;
 use crate::execution::contract_class::TrackedResource;
@@ -2220,3 +2224,82 @@ fn test_invoke_tx_with_proof_facts(
 
     assert!(!tx_execution_info.is_reverted());
 }
+
+/// Converts SnosProofFacts to ProofFacts for testing.
+fn snos_to_proof_facts(snos: SnosProofFacts) -> ProofFacts {
+    vec![
+        felt!(VIRTUAL_SNOS),
+        snos.program_hash,
+        felt!(snos.block_number.0),
+        snos.block_hash.0,
+        snos.config_hash,
+    ]
+    .into()
+}
+
+/// Returns invalid proof_facts with a too recent block number (at the boundary).
+fn too_recent_block_proof_facts() -> ProofFacts {
+    let mut snos_proof_facts =
+        SnosProofFacts::try_from(ProofFacts::snos_proof_facts_for_testing()).unwrap();
+    // Block number at the boundary: current - STORED_BLOCK_HASH_BUFFER, which is >= max_allowed.
+    snos_proof_facts.block_number = BlockNumber(CURRENT_BLOCK_NUMBER - STORED_BLOCK_HASH_BUFFER);
+    snos_to_proof_facts(snos_proof_facts)
+}
+
+/// Returns invalid proof_facts with a mismatched block hash.
+fn mismatched_hash_proof_facts() -> ProofFacts {
+    let mut snos_proof_facts =
+        SnosProofFacts::try_from(ProofFacts::snos_proof_facts_for_testing()).unwrap();
+    //
+    snos_proof_facts.block_hash = BlockHash(snos_proof_facts.block_hash.0 + 1);
+    snos_to_proof_facts(snos_proof_facts)
+}
+
+/// Returns invalid proof_facts with a zero block hash.
+fn zero_block_hash_proof_facts() -> ProofFacts {
+    let mut snos_proof_facts = SnosProofFacts::try_from(ProofFacts::snos_proof_facts_for_testing())
+        .expect("Invalid proof facts");
+    snos_proof_facts.block_hash = BlockHash(Felt::ZERO);
+    snos_to_proof_facts(snos_proof_facts)
+}
+
+/// Tests the `validate_proof_facts` function for Invoke V3 transactions.
+/// Covers: valid proof facts, too recent block number, mismatched block hash, future block,
+/// current block too small, and zero block hash.
+#[rstest]
+#[case::valid_proof_facts(ProofFacts::snos_proof_facts_for_testing(), CURRENT_BLOCK_NUMBER)]
+#[should_panic(expected = "is too recent. The maximum allowed")]
+#[case::too_recent_block(too_recent_block_proof_facts(), CURRENT_BLOCK_NUMBER)]
+#[should_panic(expected = "Block hash mismatch")]
+#[case::mismatched_block_hash(mismatched_hash_proof_facts(), CURRENT_BLOCK_NUMBER)]
+#[should_panic(expected = "is too recent to have a stored block hash")]
+#[case::current_block_too_small(
+    ProofFacts::snos_proof_facts_for_testing(),
+    STORED_BLOCK_HASH_BUFFER - 1,
+)]
+#[should_panic(expected = "Stored block hash is zero")]
+#[case::zero_block_hash(zero_block_hash_proof_facts(), CURRENT_BLOCK_NUMBER)]
+fn test_validate_proof_facts(
+    default_all_resource_bounds: ValidResourceBounds,
+    #[case] proof_facts: ProofFacts,
+    #[case] current_block_number: u64,
+) {
+    let mut block_context = BlockContext::create_for_account_testing();
+    block_context.block_info.block_number = BlockNumber(current_block_number);
+
+    let chain_info = &block_context.chain_info;
+    let account =
+        FeatureContract::AccountWithoutValidations(CairoVersion::Cairo1(RunnableCairo1::Casm));
+    let mut state = test_state(chain_info, BALANCE, &[(account, 1u16)]);
+    let account_address = account.get_instance_address(0_u16);
+
+    let tx = invoke_tx_with_default_flags(invoke_tx_args! {
+        sender_address: account_address,
+        resource_bounds: default_all_resource_bounds,
+        proof_facts,
+    });
+
+    // Run only pre-validation stage (which includes proof facts validation).
+    let tx_context = block_context.to_tx_context(&tx);
+    tx.perform_pre_validation_stage(&mut state, &tx_context).unwrap();
+}

crates/starknet_api/src/transaction/fields.rs

@@ -701,6 +701,18 @@ impl From<Vec<Felt>> for ProofFacts {
     }
 }
 
+impl TryFrom<ProofFacts> for SnosProofFacts {
+    type Error = StarknetApiError;
+    fn try_from(proof_facts: ProofFacts) -> Result<Self, Self::Error> {
+        match ProofFactsVariant::try_from(&proof_facts) {
+            Ok(ProofFactsVariant::Snos(snos_proof_facts)) => Ok(snos_proof_facts),
+            _ => Err(StarknetApiError::InvalidProofFacts(format!(
+                "Invalid SNOS proof facts: {proof_facts:?}",
+            ))),
+        }
+    }
+}
+
 /// Client-provided proof used for client-side proving.
 #[derive(
     Clone,