starknet_transaction_prover: accept newer starknet versions (#14387)

Author: einat-starkware

crates/starknet_os/src/hints/hint_implementation/os.rs

@@ -3,6 +3,7 @@ use std::collections::{BTreeSet, HashMap};
 use blockifier::state::state_api::StateReader;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use starknet_api::block_hash::block_hash_calculator::gas_prices_to_hash;
+use starknet_api::core::ascii_as_felt;
 use starknet_types_core::felt::Felt;
 
 use crate::hint_processor::snos_hint_processor::SnosHintProcessor;
@@ -186,8 +187,13 @@ pub(crate) fn get_block_hashes<S: StateReader>(
     )?;
     ctx.insert_value(Ids::HeaderCommitments, header_commitments_ptr)?;
 
-    let starknet_version_felt = Felt::try_from(&block_info.starknet_version)?;
-    ctx.insert_value(Ids::StarknetVersion, starknet_version_felt)?;
+    // The on-chain block hash commits to the exact ASCII encoding of the version string, which
+    // may be newer than the latest known `StarknetVersion` variant.
+    let starknet_version_string = os_input
+        .starknet_version_override
+        .clone()
+        .unwrap_or_else(|| block_info.starknet_version.to_string());
+    ctx.insert_value(Ids::StarknetVersion, ascii_as_felt(&starknet_version_string)?)?;
 
     let [gas_prices_hash]: [Felt; 1] = gas_prices_to_hash(
         &gas_prices.l1_gas_price_per_token(),

crates/starknet_os/src/io/os_input.rs

@@ -50,6 +50,11 @@ pub struct OsBlockInput {
     // A mapping from Cairo 1 declared class hashes to the hashes of the contract class components.
     pub declared_class_hash_to_component_hashes: HashMap<ClassHash, ContractClassComponentHashes>,
     pub block_info: BlockInfo,
+    // When set, the OS recomputes the block hash from this exact version string instead of
+    // `block_info.starknet_version`. Required when the block's on-chain version is newer than the
+    // latest known `StarknetVersion` variant.
+    #[cfg_attr(feature = "deserialize", serde(default))]
+    pub starknet_version_override: Option<String>,
     pub block_hash_commitments: BlockHeaderCommitments,
     pub prev_block_hash: BlockHash,
     pub new_block_hash: BlockHash,

crates/starknet_os_flow_tests/src/test_manager.rs

@@ -927,6 +927,7 @@ impl<S: FlowTestState> TestBuilder<S> {
                 prev_block_hash,
                 new_block_hash,
                 block_info,
+                starknet_version_override: None,
                 block_hash_commitments,
                 old_block_number_and_hash,
                 class_hashes_to_migrate: Vec::new(),

crates/starknet_transaction_prover/src/running/runner.rs

@@ -51,6 +51,9 @@ pub(crate) struct VirtualOsBlockInput {
     transactions: Vec<(InvokeTransaction, TransactionHash)>,
     tx_execution_infos: Vec<CentralTransactionExecutionInfo>,
     block_info: BlockInfo,
+    /// The base block's version string as returned by the RPC; used by the OS to recompute the
+    /// base block hash (may be newer than the latest known `StarknetVersion`).
+    raw_starknet_version: String,
     initial_reads: StateMaps,
     base_block_hash: BlockHash,
     base_block_header_commitments: BlockHeaderCommitments,
@@ -83,6 +86,7 @@ impl From<VirtualOsBlockInput> for OsHints {
             tx_execution_infos: virtual_os_block_input.tx_execution_infos,
             prev_block_hash: virtual_os_block_input.prev_base_block_hash,
             block_info: virtual_os_block_input.block_info,
+            starknet_version_override: Some(virtual_os_block_input.raw_starknet_version),
             initial_reads: virtual_os_block_input.initial_reads,
             declared_class_hash_to_component_hashes: HashMap::new(),
             new_block_hash: virtual_os_block_input.base_block_hash,
@@ -238,6 +242,7 @@ where
             transactions: txs,
             tx_execution_infos,
             block_info: execution_data.base_block_info.block_context.block_info().clone(),
+            raw_starknet_version: execution_data.base_block_info.raw_starknet_version,
             initial_reads: extended_initial_reads,
             base_block_hash: execution_data.base_block_info.base_block_hash,
             base_block_header_commitments: execution_data

crates/starknet_transaction_prover/src/running/storage_proofs_test.rs

@@ -3,7 +3,7 @@ use std::collections::HashSet;
 use blockifier::context::BlockContext;
 use blockifier::state::cached_state::StateMaps;
 use rstest::rstest;
-use starknet_api::block::{BlockHash, BlockNumber};
+use starknet_api::block::{BlockHash, BlockNumber, StarknetVersion};
 use starknet_api::block_hash::block_hash_calculator::BlockHeaderCommitments;
 use starknet_api::core::ContractAddress;
 use starknet_api::state::StorageKey;
@@ -67,6 +67,7 @@ fn test_get_storage_proofs_from_rpc(
         l2_to_l1_messages: Vec::new(),
         base_block_info: BaseBlockInfo {
             block_context: BlockContext::create_for_account_testing(),
+            raw_starknet_version: StarknetVersion::LATEST.to_string(),
             base_block_hash: BlockHash::default(),
             prev_base_block_hash: BlockHash::default(),
             base_block_header_commitments: BlockHeaderCommitments::default(),

crates/starknet_transaction_prover/src/running/virtual_block_executor.rs

@@ -23,13 +23,14 @@ use blockifier_reexecution::state_reader::prefetched_state_reader::{
 use blockifier_reexecution::state_reader::rpc_objects::{BlockHeader, BlockId};
 use blockifier_reexecution::state_reader::rpc_state_reader::RpcStateReader;
 use serde::{Deserialize, Serialize};
-use starknet_api::block::{BlockHash, BlockInfo};
+use starknet_api::block::{BlockHash, BlockInfo, StarknetVersion};
 use starknet_api::block_hash::block_hash_calculator::{concat_counts, BlockHeaderCommitments};
 use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::ClassHash;
 use starknet_api::transaction::fields::Fee;
 use starknet_api::transaction::{InvokeTransaction, MessageToL1, Transaction, TransactionHash};
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
+use starknet_api::StarknetApiError;
 use tracing::error;
 
 use crate::errors::VirtualBlockExecutorError;
@@ -75,6 +76,9 @@ impl Default for RpcVirtualBlockExecutorConfig {
 /// This struct contains all the execution data needed for proof generation.
 pub(crate) struct BaseBlockInfo {
     pub(crate) block_context: BlockContext,
+    /// The base block's version string exactly as returned by the RPC; may be newer than the
+    /// latest known `StarknetVersion`. The OS uses it to recompute the base block hash.
+    pub(crate) raw_starknet_version: String,
     /// The block hash of the base block,
     /// in which the virtual block is executed.
     pub(crate) base_block_hash: BlockHash,
@@ -91,7 +95,7 @@ impl BaseBlockInfo {
     /// When `use_latest_versioned_constants` is `true`, the latest versioned constants are used
     /// instead of the ones matching the block's Starknet version.
     pub(crate) fn new(
-        header: BlockHeader,
+        mut header: BlockHeader,
         chain_info: ChainInfo,
         use_latest_versioned_constants: bool,
     ) -> Result<Self, VirtualBlockExecutorError> {
@@ -110,6 +114,17 @@ impl BaseBlockInfo {
             ),
         };
 
+        let raw_starknet_version = header.starknet_version.clone();
+        // Versions newer than the latest known one are executed with the latest known semantics;
+        // the raw version string is kept separately so the OS recomputes the on-chain block hash
+        // from the exact version string.
+        header.starknet_version = starknet_version_or_latest(&raw_starknet_version)
+            .map_err(|e| {
+                VirtualBlockExecutorError::TransactionExecutionError(format!(
+                    "Unsupported starknet version in block header: {e}"
+                ))
+            })?
+            .to_string();
         let block_info: BlockInfo = header.try_into().map_err(|e| {
             VirtualBlockExecutorError::TransactionExecutionError(format!(
                 "Failed to convert block header to block info: {e}"
@@ -141,13 +156,31 @@ impl BaseBlockInfo {
 
         Ok(BaseBlockInfo {
             block_context,
+            raw_starknet_version,
             base_block_hash,
             base_block_header_commitments,
             prev_base_block_hash,
         })
     }
 }
 
+/// Returns the [StarknetVersion] matching the given version string, falling back to
+/// [StarknetVersion::LATEST] for versions newer than `LATEST`
+pub(crate) fn starknet_version_or_latest(
+    version_string: &str,
+) -> Result<StarknetVersion, StarknetApiError> {
+    match StarknetVersion::try_from(version_string) {
+        // `InvalidStarknetVersion` carries the parsed version segments, whose lexicographic order
+        // matches version order.
+        Err(StarknetApiError::InvalidStarknetVersion(segments))
+            if segments > Vec::<u8>::from(StarknetVersion::LATEST) =>
+        {
+            Ok(StarknetVersion::LATEST)
+        }
+        result => result,
+    }
+}
+
 pub(crate) struct VirtualBlockExecutionData {
     /// Execution outputs for all transactions in the virtual block.
     pub(crate) execution_outputs: Vec<TransactionExecutionOutput>,

crates/starknet_transaction_prover/src/running/virtual_block_executor_test.rs

@@ -2,11 +2,11 @@ use assert_matches::assert_matches;
 use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::bouncer::{BouncerConfig, BouncerWeights};
 use blockifier::state::contract_class_manager::ContractClassManager;
-use blockifier_reexecution::state_reader::rpc_objects::BlockId;
+use blockifier_reexecution::state_reader::rpc_objects::{BlockHeader, BlockId};
 use blockifier_reexecution::utils::get_chain_info;
 use rstest::rstest;
 use starknet_api::abi::abi_utils::{get_storage_var_address, selector_from_name};
-use starknet_api::block::BlockNumber;
+use starknet_api::block::{BlockNumber, GasPrice, GasPricePerToken, StarknetVersion};
 use starknet_api::core::{ChainId, ContractAddress, Nonce};
 use starknet_api::test_utils::invoke::invoke_tx;
 use starknet_api::transaction::fields::ValidResourceBounds;
@@ -15,6 +15,8 @@ use starknet_api::{calldata, felt, invoke_tx_args};
 
 use crate::errors::VirtualBlockExecutorError;
 use crate::running::virtual_block_executor::{
+    starknet_version_or_latest,
+    BaseBlockInfo,
     RpcVirtualBlockExecutor,
     RpcVirtualBlockExecutorConfig,
     VirtualBlockExecutor,
@@ -267,3 +269,91 @@ fn test_execute_rejected_by_tight_bouncer_limits(
             if msg.contains("Transaction size exceeds the maximum block capacity")
     );
 }
+
+/// Returns a block header with the given version string and nonzero gas prices (zero gas prices
+/// fail the `BlockInfo` conversion).
+fn block_header_with_version(starknet_version: &str) -> BlockHeader {
+    let nonzero_gas_price =
+        GasPricePerToken { price_in_wei: GasPrice(1), price_in_fri: GasPrice(1) };
+    BlockHeader {
+        starknet_version: starknet_version.to_string(),
+        l1_gas_price: nonzero_gas_price,
+        l1_data_gas_price: nonzero_gas_price,
+        l2_gas_price: nonzero_gas_price,
+        ..Default::default()
+    }
+}
+
+/// Verifies that the base block info keeps the raw version string for the OS while falling back
+/// to the latest known version for execution when the block's version is newer than this binary.
+#[rstest]
+#[case::known_version("0.14.2", StarknetVersion::V0_14_2)]
+#[case::unknown_newer_version("0.20.0", StarknetVersion::LATEST)]
+fn test_base_block_info_starknet_version_handling(
+    #[case] version_string: &str,
+    #[case] expected_execution_version: StarknetVersion,
+    #[values(true, false)] use_latest_versioned_constants: bool,
+) {
+    let base_block_info = BaseBlockInfo::new(
+        block_header_with_version(version_string),
+        get_chain_info(&ChainId::Mainnet, None),
+        use_latest_versioned_constants,
+    )
+    .unwrap();
+
+    assert_eq!(base_block_info.raw_starknet_version, version_string);
+    assert_eq!(
+        base_block_info.block_context.block_info().starknet_version,
+        expected_execution_version
+    );
+}
+
+#[rstest]
+#[case::non_numeric_version("not.a.version")]
+#[case::unknown_old_version("0.13.7")]
+fn test_base_block_info_rejects_invalid_version(#[case] version_string: &str) {
+    let base_block_info_result = BaseBlockInfo::new(
+        block_header_with_version(version_string),
+        get_chain_info(&ChainId::Mainnet, None),
+        true,
+    );
+    assert!(base_block_info_result.is_err());
+}
+
+/// Verifies the version-string parsing of `starknet_version_or_latest`: known version strings
+/// parse to their exact variant, and strings strictly newer than `LATEST` fall back to `LATEST`.
+#[rstest]
+#[case::known_three_segment_version("0.13.2", StarknetVersion::V0_13_2)]
+#[case::known_four_segment_version("0.13.1.1", StarknetVersion::V0_13_1_1)]
+#[case::newer_minor_version("0.15.0", StarknetVersion::LATEST)]
+#[case::newer_major_version("1.0.0", StarknetVersion::LATEST)]
+fn test_starknet_version_or_latest_parsing(
+    #[case] version_string: &str,
+    #[case] expected_version: StarknetVersion,
+) {
+    assert_eq!(starknet_version_or_latest(version_string).unwrap(), expected_version);
+}
+
+/// The exact `LATEST` version string must parse back to `LATEST`, regardless of which version
+/// that currently is.
+#[test]
+fn test_starknet_version_or_latest_roundtrips_latest() {
+    assert_eq!(
+        starknet_version_or_latest(&StarknetVersion::LATEST.to_string()).unwrap(),
+        StarknetVersion::LATEST
+    );
+}
+
+/// Verifies that `starknet_version_or_latest` rejects malformed version strings and unknown
+/// versions that are not newer than `LATEST` (only newer-than-`LATEST` versions fall back).
+#[rstest]
+#[case::unknown_older_version("0.13.7")]
+#[case::truncated_latest_version("0.14")]
+#[case::non_numeric_version("not.a.version")]
+#[case::empty_string("")]
+#[case::segment_exceeding_u8("0.14.300")]
+#[case::trailing_dot("0.14.3.")]
+#[case::release_candidate_suffix("0.15.0-rc.1")]
+fn test_starknet_version_or_latest_rejects_invalid_version(#[case] version_string: &str) {
+    assert!(starknet_version_or_latest(version_string).is_err());
+}