starknet_transaction_prover: make prover forward compatible

Author: einat-starkware

crates/starknet_transaction_prover/src/running/virtual_block_executor.rs

@@ -23,14 +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 tracing::error;
+use tracing::{error, warn};
 
 use crate::errors::VirtualBlockExecutorError;
 
@@ -85,13 +85,45 @@ pub(crate) struct BaseBlockInfo {
     pub(crate) prev_base_block_hash: BlockHash,
 }
 
+/// Parses the block header's Starknet version, tolerating versions newer than this binary knows.
+///
+/// `StarknetVersion` is a closed enum, so a block produced by a Starknet version released after
+/// this binary was built can't be parsed. The prover runs the OS with the latest versioned
+/// constants regardless of the block's version, so a *strictly newer* version is treated as
+/// `StarknetVersion::LATEST`. Older or malformed versions still error — we only forgive the
+/// forward-compatibility case, never mask genuinely unsupported data.
+pub(crate) fn forward_compatible_starknet_version(
+    raw_version: &str,
+) -> Result<StarknetVersion, VirtualBlockExecutorError> {
+    if let Ok(version) = StarknetVersion::try_from(raw_version.to_string()) {
+        return Ok(version);
+    }
+    let latest = StarknetVersion::LATEST;
+    // Compare numerically: Vec<u8> orders lexicographically, matching version ordering
+    // (major, minor, patch, [fourth]).
+    let version_bytes: Result<Vec<u8>, _> =
+        raw_version.split('.').map(|component| component.parse::<u8>()).collect();
+    match version_bytes {
+        Ok(version_bytes) if version_bytes > Vec::<u8>::from(latest) => {
+            warn!(
+                "Block header reports unknown Starknet version '{raw_version}', newer than the \
+                 latest known version {latest}; falling back to {latest} for proving."
+            );
+            Ok(latest)
+        }
+        _ => Err(VirtualBlockExecutorError::TransactionExecutionError(format!(
+            "Unsupported Starknet version '{raw_version}' (latest known: {latest})"
+        ))),
+    }
+}
+
 impl BaseBlockInfo {
     /// Creates a `BaseBlockInfo` from a block header and chain info.
     ///
     /// 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 +142,10 @@ impl BaseBlockInfo {
             ),
         };
 
+        // Forward compatibility: tolerate versions newer than this binary knows (see helper).
+        let starknet_version = forward_compatible_starknet_version(&header.starknet_version)?;
+        header.starknet_version = starknet_version.to_string();
+
         let block_info: BlockInfo = header.try_into().map_err(|e| {
             VirtualBlockExecutorError::TransactionExecutionError(format!(
                 "Failed to convert block header to block info: {e}"

crates/starknet_transaction_prover/src/running/virtual_block_executor_test.rs

@@ -6,7 +6,7 @@ use blockifier_reexecution::state_reader::rpc_objects::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, 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,7 @@ use starknet_api::{calldata, felt, invoke_tx_args};
 
 use crate::errors::VirtualBlockExecutorError;
 use crate::running::virtual_block_executor::{
+    forward_compatible_starknet_version,
     RpcVirtualBlockExecutor,
     RpcVirtualBlockExecutorConfig,
     VirtualBlockExecutor,
@@ -28,6 +29,34 @@ use crate::test_utils::{
     TEST_BLOCK_NUMBER,
 };
 
+/// A known version parses to its exact variant; a version strictly newer than the latest known
+/// version falls back to `StarknetVersion::LATEST` so newer blocks don't block proving.
+#[test]
+fn test_forward_compatible_version_falls_back_for_newer() {
+    assert_matches!(
+        forward_compatible_starknet_version("0.14.2"),
+        Ok(version) if version == StarknetVersion::V0_14_2
+    );
+    assert_matches!(
+        forward_compatible_starknet_version("0.14.3"),
+        Ok(version) if version == StarknetVersion::LATEST
+    );
+    assert_matches!(
+        forward_compatible_starknet_version("0.99.0"),
+        Ok(version) if version == StarknetVersion::LATEST
+    );
+}
+
+/// Unknown versions that are older than the latest known version, or malformed, must error —
+/// the fallback only forgives strictly-newer versions, it never masks genuinely bad data.
+#[test]
+fn test_forward_compatible_version_rejects_older_and_malformed() {
+    // [0, 13, 99] < [0, 14, 2], so this is an unknown *older* version.
+    assert_matches!(forward_compatible_starknet_version("0.13.99"), Err(_));
+    assert_matches!(forward_compatible_starknet_version("not.a.version"), Err(_));
+    assert_matches!(forward_compatible_starknet_version(""), Err(_));
+}
+
 /// Constructs an Invoke transaction that calls `balanceOf` on the STRK token contract.
 ///
 /// Since we skip validation and fee charging, we can use dummy values for signature,