blockifier: verify that the proof facts block number matches the block hash

Author: meship-starkware

crates/apollo_gateway/src/gateway_test.rs

@@ -38,7 +38,7 @@ use apollo_network_types::network_types::BroadcastedMessageMetadata;
 use apollo_test_utils::{get_rng, GetTestInstance};
 use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::context::ChainInfo;
-use blockifier::test_utils::initial_test_state::fund_account;
+use blockifier::test_utils::initial_test_state::{fund_account, store_block_hash_from_proof_facts};
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::calldata::create_trivial_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
@@ -52,6 +52,7 @@ use starknet_api::executable_transaction::AccountTransaction;
 use starknet_api::rpc_transaction::{
     InternalRpcTransaction,
     RpcDeclareTransaction,
+    RpcInvokeTransaction,
     RpcTransaction,
     RpcTransactionLabelValue,
 };
@@ -284,6 +285,13 @@ async fn setup_mock_state(
         &mut mock_dependencies.state_reader_factory.state_reader.blockifier_state_reader,
     );
 
+    if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(invoke_tx)) = input_tx.clone() {
+        store_block_hash_from_proof_facts(
+            &invoke_tx.proof_facts,
+            &mut mock_dependencies.state_reader_factory.state_reader.blockifier_state_reader,
+        );
+    }
+
     let mempool_add_tx_args = AddTransactionArgs {
         tx: expected_internal_tx.clone(),
         account_state: AccountState { address, nonce: *input_tx.nonce() },

crates/blockifier/src/test_utils/initial_test_state.rs

@@ -5,10 +5,12 @@ use starknet_api::block::FeeType;
 use starknet_api::contract_class::compiled_class_hash::HashVersion;
 use starknet_api::core::ContractAddress;
 use starknet_api::felt;
-use starknet_api::transaction::fields::Fee;
+use starknet_api::state::StorageKey;
+use starknet_api::transaction::fields::{Fee, ProofFacts, ProofFactsVariant};
 use strum::IntoEnumIterator;
 
 use crate::blockifier::config::ContractClassManagerConfig;
+use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::context::ChainInfo;
 use crate::state::cached_state::CachedState;
 use crate::state::contract_class_manager::ContractClassManager;
@@ -36,6 +38,26 @@ pub fn fund_account(
     }
 }
 
+/// Stores block hash in the block hash contract from SNOS proof facts.
+/// This is a generic helper that can be used in any test that needs to set up block hashes
+/// for proof facts validation.
+pub fn store_block_hash_from_proof_facts(
+    proof_facts: &ProofFacts,
+    state_reader: &mut DictStateReader,
+) {
+    if let Ok(ProofFactsVariant::Snos(snos_proof_facts)) = ProofFactsVariant::try_from(proof_facts)
+    {
+        let block_hash_contract_address = VersionedConstants::create_for_testing()
+            .os_constants
+            .os_contract_addresses
+            .block_hash_contract_address();
+        state_reader.storage_view.insert(
+            (block_hash_contract_address, StorageKey::from(snos_proof_facts.block_number.0)),
+            snos_proof_facts.block_hash.0,
+        );
+    }
+}
+
 /// Sets up a state reader for testing:
 /// * "Declares" a Cairo0 ERC20 contract (class hash => class mapping set).
 /// * "Deploys" two ERC20 contracts (address => class hash mapping set) at the fee token addresses
@@ -83,6 +105,7 @@ pub fn setup_test_state(
     }
 }
 
+// TODO(Meshi): create a client-side test state.
 pub fn test_state(
     chain_info: &ChainInfo,
     initial_balances: Fee,

crates/blockifier/src/transaction/account_transaction.rs

@@ -1,13 +1,14 @@
 use std::sync::Arc;
 
 use starknet_api::abi::abi_utils::selector_from_name;
-use starknet_api::block::GasPriceVector;
+use starknet_api::block::{BlockNumber, GasPriceVector};
 use starknet_api::calldata;
 use starknet_api::contract_class::EntryPointType;
 use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, Nonce};
 use starknet_api::data_availability::DataAvailabilityMode;
 use starknet_api::executable_transaction::{AccountTransaction as Transaction, TransactionType};
 use starknet_api::execution_resources::GasAmount;
+use starknet_api::state::StorageKey;
 use starknet_api::transaction::fields::Resource::{L1DataGas, L1Gas, L2Gas};
 use starknet_api::transaction::fields::{
     AccountDeploymentData,
@@ -24,6 +25,8 @@ use starknet_api::transaction::{constants, TransactionHash, TransactionVersion};
 use starknet_types_core::felt::Felt;
 
 use super::errors::ResourceBoundsError;
+use crate::abi::constants::STORED_BLOCK_HASH_BUFFER;
+use crate::blockifier_versioned_constants::OsConstants;
 use crate::context::{BlockContext, GasCounter, TransactionContext};
 use crate::execution::call_info::CallInfo;
 use crate::execution::common_hints::ExecutionMode;
@@ -246,19 +249,65 @@ impl AccountTransaction {
         }
     }
 
-    fn validate_proof_facts(&self) -> TransactionPreValidationResult<()> {
-        if let Transaction::Invoke(tx) = &self.tx {
-            if tx.tx.version() == TransactionVersion::THREE {
-                let proof_facts_variant = ProofFactsVariant::try_from(&tx.tx.proof_facts())
-                    .map_err(|e| TransactionPreValidationError::InvalidProofFacts(e.to_string()))?;
-                match proof_facts_variant {
-                    ProofFactsVariant::Empty => {}
-                    ProofFactsVariant::Snos(_snos_proof_facts) => {
-                        // TODO(Meshi/ AvivG): add proof facts validations.
-                    }
-                }
-            }
+    fn validate_proof_facts(
+        &self,
+        os_constants: &OsConstants,
+        current_block_number: BlockNumber,
+        state: &mut dyn State,
+    ) -> TransactionPreValidationResult<()> {
+        // Only Invoke V3 transactions can carry proof facts that we validate here.
+        let Transaction::Invoke(invoke_tx) = &self.tx else {
+            return Ok(());
+        };
+        if invoke_tx.version() != TransactionVersion::THREE {
+            return Ok(());
+        }
+        let proof_facts = invoke_tx.proof_facts();
+        let proof_facts_variant = ProofFactsVariant::try_from(&proof_facts)
+            .map_err(|e| TransactionPreValidationError::InvalidProofFacts(e.to_string()))?;
+
+        let snos_proof_facts = match proof_facts_variant {
+            ProofFactsVariant::Empty => return Ok(()),
+            ProofFactsVariant::Snos(snos_proof_facts) => snos_proof_facts,
+        };
+
+        let proof_block_number = snos_proof_facts.block_number;
+        let proof_block_hash = snos_proof_facts.block_hash.0;
+
+        if current_block_number.0 < proof_block_number.0 {
+            return Err(TransactionPreValidationError::InvalidProofFacts(format!(
+                "Current block number {current_block_number} is less than proof block number \
+                 {proof_block_number}."
+            )));
+        }
+
+        // Validate the proof block number is not too recent.
+        // Block-number to block-hash mapping is only guaranteed up to
+        // current_block_number - STORED_BLOCK_HASH_BUFFER.
+        if current_block_number.0 <= STORED_BLOCK_HASH_BUFFER + proof_block_number.0 {
+            return Err(TransactionPreValidationError::InvalidProofFacts(format!(
+                "Proof block number {proof_block_number} is too recent. Block hashes are only \
+                 available for blocks ≤ current_block_number - STORED_BLOCK_HASH_BUFFER \
+                 ({current_block_number} - {STORED_BLOCK_HASH_BUFFER})."
+            )));
+        }
+
+        // Validate that the proof block hash matches the stored hash.
+        let block_hash_contract_address =
+            os_constants.os_contract_addresses.block_hash_contract_address();
+
+        let stored_block_hash = state
+            .get_storage_at(block_hash_contract_address, StorageKey::from(proof_block_number.0))?;
+
+        assert_ne!(stored_block_hash, Felt::ZERO, "Stored block hash is zero");
+
+        if stored_block_hash != proof_block_hash {
+            return Err(TransactionPreValidationError::InvalidProofFacts(format!(
+                "Block hash mismatch for block {proof_block_number}. Proof block hash: \
+                 {proof_block_hash}, stored block hash: {stored_block_hash}."
+            )));
         }
+
         Ok(())
     }
 
@@ -278,7 +327,11 @@ impl AccountTransaction {
             verify_can_pay_committed_bounds(state, tx_context).map_err(Box::new)?;
         }
 
-        self.validate_proof_facts()?;
+        self.validate_proof_facts(
+            &tx_context.block_context.versioned_constants.os_constants,
+            tx_context.block_context.block_info.block_number,
+            state,
+        )?;
 
         Ok(())
     }

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,
@@ -55,9 +56,12 @@ use starknet_api::transaction::fields::{
     ContractAddressSalt,
     Fee,
     GasVectorComputationMode,
+    ProofFacts,
     Resource,
     ResourceBounds,
+    SnosProofFacts,
     ValidResourceBounds,
+    VIRTUAL_SNOS,
 };
 use starknet_api::transaction::{
     DeclareTransaction,
@@ -79,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;
@@ -2191,3 +2196,119 @@ fn test_missing_validate_entrypoint_rejects(
         if ret == retdata![Felt::from_hex(ENTRYPOINT_NOT_FOUND_ERROR).unwrap()]
     );
 }
+
+/// 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 valid SNOS proof facts.
+/// Block number must be more than STORED_BLOCK_HASH_BUFFER blocks old (difference > buffer).
+fn valid_snos_proof_facts() -> SnosProofFacts {
+    SnosProofFacts {
+        program_hash: felt!(0x1_u64),
+        block_number: BlockNumber(CURRENT_BLOCK_NUMBER - STORED_BLOCK_HASH_BUFFER - 1),
+        block_hash: BlockHash(felt!(0xABCDEF_u64)),
+        config_hash: felt!(0x2_u64),
+    }
+}
+
+/// Returns valid proof facts.
+fn valid_proof_facts() -> ProofFacts {
+    snos_to_proof_facts(valid_snos_proof_facts())
+}
+
+/// Returns invalid proof_facts with a too recent block number.
+fn too_recent_block_proof_facts() -> ProofFacts {
+    snos_to_proof_facts(SnosProofFacts {
+        block_number: BlockNumber(CURRENT_BLOCK_NUMBER - STORED_BLOCK_HASH_BUFFER),
+        ..valid_snos_proof_facts()
+    })
+}
+
+/// Returns invalid proof_facts with a mismatched block hash.
+fn mismatched_hash_proof_facts() -> ProofFacts {
+    snos_to_proof_facts(SnosProofFacts {
+        block_hash: BlockHash(felt!(0xDEADBEEF_u64)),
+        ..valid_snos_proof_facts()
+    })
+}
+
+/// Returns invalid proof_facts with a block number greater than the current block number.
+fn future_block_proof_facts() -> ProofFacts {
+    snos_to_proof_facts(SnosProofFacts {
+        block_number: BlockNumber(CURRENT_BLOCK_NUMBER + 100),
+        ..valid_snos_proof_facts()
+    })
+}
+
+/// Returns invalid proof_facts with block number 0 (for testing low current block number).
+fn block_zero_proof_facts() -> ProofFacts {
+    snos_to_proof_facts(SnosProofFacts { block_number: BlockNumber(0), ..valid_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,
+/// and low current block number.
+#[rstest]
+#[case::valid_proof_facts(valid_proof_facts(), CURRENT_BLOCK_NUMBER)]
+#[should_panic(expected = "is too recent")]
+#[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 less than proof block number")]
+#[case::future_block(future_block_proof_facts(), CURRENT_BLOCK_NUMBER)]
+#[should_panic(expected = "is less than STORED_BLOCK_HASH_BUFFER")]
+#[case::low_current_block_number(block_zero_proof_facts(), STORED_BLOCK_HASH_BUFFER)]
+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::Cairo0);
+    let mut state = test_state(chain_info, BALANCE, &[(account, 1u16)]);
+    let account_address = account.get_instance_address(0_u16);
+
+    // Get the block hash contract address from versioned constants.
+    let block_hash_contract_address = block_context
+        .versioned_constants
+        .os_constants
+        .os_contract_addresses
+        .block_hash_contract_address();
+
+    // Store block hashes for test blocks.
+    // Valid block number: more than STORED_BLOCK_HASH_BUFFER blocks old.
+    let valid_proof_block_number = CURRENT_BLOCK_NUMBER - STORED_BLOCK_HASH_BUFFER - 1;
+    let stored_block_hash = felt!(0xABCDEF_u64);
+
+    // Store the block hash in the block hash contract.
+    state
+        .set_storage_at(
+            block_hash_contract_address,
+            StorageKey::try_from(felt!(valid_proof_block_number)).unwrap(),
+            stored_block_hash,
+        )
+        .unwrap();
+
+    let tx = invoke_tx_with_default_flags(invoke_tx_args! {
+        sender_address: account_address,
+        resource_bounds: default_all_resource_bounds,
+        version: TransactionVersion::THREE,
+        proof_facts: 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();
+}