apollo_integration_tests: add regression tests for matching the proof generation

Author: einat-starkware

Cargo.lock

@@ -64,6 +64,7 @@ blockifier = { workspace = true, features = ["testing"] }
 blockifier_test_utils.workspace = true
 cairo-lang-starknet-classes.workspace = true
 clap = { workspace = true, features = ["derive"] }
+expect-test.workspace = true
 futures.workspace = true
 hex.workspace = true
 http.workspace = true

crates/apollo_integration_tests/Cargo.toml

@@ -21,7 +21,9 @@ use assert_matches::assert_matches;
 use blockifier::context::ChainInfo;
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::contracts::FeatureContract;
+use blockifier_test_utils::fee_token_addresses::EXPECTED_STRK_FEE_TOKEN_ADDRESS;
 use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
+use expect_test::{expect, Expect};
 use indexmap::IndexMap;
 use mempool_test_utils::starknet_api_test_utils::{AccountTransactionGenerator, Contract};
 use starknet_api::abi::abi_utils::get_fee_token_var_address;
@@ -376,8 +378,14 @@ fn initialize_papyrus_test_state(
 }
 
 /// Global root that matches the proof flow fixtures.
-fn integration_test_genesis_global_root() -> GlobalRoot {
-    GlobalRoot(felt!("0x68fed6a062d385db8d1dd9096060e822196feb311fc3bb4f0018635461ca85e"))
+/// Any change to this value requires regenerating the proof fixtures by running
+/// `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
+/// starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`.
+pub const EXPECTED_PROOF_FLOW_GENESIS_GLOBAL_ROOT: Expect =
+    expect!["0x68fed6a062d385db8d1dd9096060e822196feb311fc3bb4f0018635461ca85e"];
+
+pub fn integration_test_genesis_global_root() -> GlobalRoot {
+    GlobalRoot(Felt::from_hex_unchecked(EXPECTED_PROOF_FLOW_GENESIS_GLOBAL_ROOT.data()))
 }
 
 fn prepare_state_diff(
@@ -667,6 +675,7 @@ impl<'a> ThinStateDiffBuilder<'a> {
 pub fn proof_flow_chain_info() -> ChainInfo {
     let mut chain_info = ChainInfo::create_for_testing();
     chain_info.fee_token_addresses.strk_fee_token_address =
-        contract_address!("0x4ff17bf76a1c6cebb82601a43bcab4f9650aea543c44f28e8863f8b624e4b58");
+        ContractAddress::try_from(Felt::from_hex_unchecked(EXPECTED_STRK_FEE_TOKEN_ADDRESS.data()))
+            .unwrap();
     chain_info
 }

crates/apollo_integration_tests/src/state_reader.rs

@@ -1,4 +1,7 @@
 use apollo_integration_tests::utils::{load_proof_flow_proof, load_proof_flow_proof_facts};
+use blockifier::blockifier_versioned_constants::VersionedConstants;
+use starknet_api::transaction::fields::SnosProofFacts;
+use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_proof_verifier::verify_proof;
 
 #[test]
@@ -14,3 +17,24 @@ fn proof_flow_fixtures_verify() {
         );
     }
 }
+
+/// Guards against drift between the virtual-OS program hash baked into the proof-flow fixtures
+/// and the `allowed_virtual_os_program_hashes` list in the latest versioned constants. If the
+/// hash is no longer allowed, the proof fixtures must be regenerated.
+#[test]
+fn proof_flow_program_hash_is_allowed() {
+    let proof_facts = load_proof_flow_proof_facts();
+    let snos_proof_facts = SnosProofFacts::try_from(proof_facts)
+        .expect("proof_facts.json is malformed; regenerate the fixtures");
+    let allowed =
+        &VersionedConstants::latest_constants().os_constants.allowed_virtual_os_program_hashes;
+    assert!(
+        allowed.contains(&snos_proof_facts.program_hash),
+        "Virtual OS program hash {:#x} baked into the proof_flow fixtures is no longer in the \
+         allowed list ({:?}). Regenerate the fixtures: `cargo +nightly-2025-07-14 test -p \
+         starknet_os_flow_tests --features starknet_transaction_prover/stwo_proving --release \
+         generate_proof_fixtures -- --ignored`.",
+        snos_proof_facts.program_hash,
+        allowed.iter().map(|h| format!("{h:#x}")).collect::<Vec<_>>(),
+    );
+}

crates/apollo_integration_tests/tests/proof_flow_fixtures_verify.rs

@@ -13,6 +13,7 @@ cairo_native = []
 apollo_infra_utils = { workspace = true, features = ["testing"] }
 cairo-lang-starknet-classes.workspace = true
 digest.workspace = true
+expect-test.workspace = true
 serde_json = { workspace = true, features = ["arbitrary_precision"] }
 sha2.workspace = true
 starknet-types-core.workspace = true
@@ -22,7 +23,6 @@ tempfile.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
-expect-test.workspace = true
 pretty_assertions.workspace = true
 rstest.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/blockifier_test_utils/Cargo.toml

@@ -0,0 +1,11 @@
+use expect_test::{expect, Expect};
+
+/// The STRK fee token address that is deployed when initializing the default initial state used
+/// by the virtual-OS flow tests and the apollo proof-flow integration tests. The resulting
+/// address depends on the nonce of the deploying account — if extra init transactions are added
+/// before the STRK fee token is deployed, the address must be updated. Run any failing test with
+/// `UPDATE_EXPECT=1` to refresh, then regenerate the proof fixtures by running
+/// `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
+/// starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`.
+pub const EXPECTED_STRK_FEE_TOKEN_ADDRESS: Expect =
+    expect!["0x4ff17bf76a1c6cebb82601a43bcab4f9650aea543c44f28e8863f8b624e4b58"];

crates/blockifier_test_utils/src/fee_token_addresses.rs

@@ -3,4 +3,5 @@ pub mod cairo_versions;
 pub mod calldata;
 pub mod compile_cache;
 pub mod contracts;
+pub mod fee_token_addresses;
 pub mod types;

crates/blockifier_test_utils/src/lib.rs

@@ -7,6 +7,7 @@ use blockifier::transaction::transaction_execution::Transaction;
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
+use blockifier_test_utils::fee_token_addresses::EXPECTED_STRK_FEE_TOKEN_ADDRESS;
 use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
 use starknet_api::block::BlockNumber;
 use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
@@ -44,7 +45,6 @@ use starknet_types_core::felt::Felt;
 
 use crate::test_manager::{
     block_context_for_flow_tests,
-    EXPECTED_STRK_FEE_TOKEN_ADDRESS,
     FUNDED_ACCOUNT_ADDRESS,
     STRK_FEE_TOKEN_ADDRESS,
 };
@@ -388,6 +388,6 @@ pub(crate) fn get_deploy_fee_token_tx_and_address(nonce: Nonce) -> (Transaction,
         nonce,
         ValidResourceBounds::create_for_testing_no_fee_enforcement(),
     );
-    EXPECTED_STRK_FEE_TOKEN_ADDRESS.assert_debug_eq(&**address);
+    EXPECTED_STRK_FEE_TOKEN_ADDRESS.assert_eq(&address.to_hex_string());
     (tx, address)
 }

crates/starknet_os_flow_tests/src/initial_state.rs

@@ -13,8 +13,8 @@ use blockifier::transaction::objects::TransactionExecutionInfo;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
+use blockifier_test_utils::fee_token_addresses::EXPECTED_STRK_FEE_TOKEN_ADDRESS;
 use cairo_vm::types::builtin_name::BuiltinName;
-use expect_test::{expect, Expect};
 use itertools::Itertools;
 use starknet_api::abi::abi_utils::{get_fee_token_var_address, selector_from_name};
 use starknet_api::block::{BlockHash, BlockInfo, BlockNumber, PreviousBlockNumber};
@@ -95,23 +95,12 @@ use crate::utils::{
     ExecutionOutput,
 };
 
-/// The STRK fee token address that was deployed when initializing the default initial state.
-/// The resulting address depends on the nonce of the deploying account - if extra init transactions
-/// are added to the initial state construction before the STRK fee token is deployed, the address
-/// must be updated.
-pub(crate) const EXPECTED_STRK_FEE_TOKEN_ADDRESS: Expect = expect![
-    r#"
-    0x4ff17bf76a1c6cebb82601a43bcab4f9650aea543c44f28e8863f8b624e4b58
-"#
-];
 const SEQUENCER_ADDRESS_FELT: Felt = Felt::from_hex_unchecked(TEST_SEQUENCER_ADDRESS);
 
 pub(crate) static STRK_FEE_TOKEN_ADDRESS: LazyLock<ContractAddress> = LazyLock::new(|| {
     ContractAddress(
-        PatriciaKey::try_from(Felt::from_hex_unchecked(
-            EXPECTED_STRK_FEE_TOKEN_ADDRESS.data.trim(),
-        ))
-        .unwrap(),
+        PatriciaKey::try_from(Felt::from_hex_unchecked(EXPECTED_STRK_FEE_TOKEN_ADDRESS.data()))
+            .unwrap(),
     )
 });
 /// The address of a funded account that is able to pay fees for transactions.

crates/starknet_os_flow_tests/src/test_manager.rs

@@ -1,16 +1,19 @@
 use std::path::Path;
 
+use apollo_integration_tests::state_reader::EXPECTED_PROOF_FLOW_GENESIS_GLOBAL_ROOT;
 use blockifier::execution::contract_class::TrackedResource;
 use blockifier::test_utils::dict_state_reader::DictStateReader;
 use blockifier::test_utils::get_valid_virtual_os_program_hash;
 use blockifier::transaction::test_utils::ExpectedExecutionInfo;
 use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
+use blockifier_test_utils::fee_token_addresses::EXPECTED_STRK_FEE_TOKEN_ADDRESS;
 use rstest::rstest;
 use starknet_api::abi::abi_utils::selector_from_name;
 use starknet_api::block::{BlockInfo, BlockNumber, BlockTimestamp};
 use starknet_api::core::EthAddress;
+use starknet_api::hash::StateRoots;
 use starknet_api::test_utils::{CURRENT_BLOCK_TIMESTAMP, TEST_SEQUENCER_ADDRESS};
 use starknet_api::transaction::fields::{ProofFacts, TransactionSignature};
 use starknet_api::transaction::{
@@ -22,7 +25,9 @@ use starknet_api::transaction::{
 use starknet_api::{calldata, contract_address, invoke_tx_args};
 use starknet_types_core::felt::Felt;
 
+use crate::initial_state::create_default_initial_state_data;
 use crate::test_manager::{
+    block_context_for_flow_tests,
     EventPredicateExpectation,
     TestBuilder,
     TestBuilderConfig,
@@ -308,3 +313,35 @@ async fn generate_proof_fixtures() {
     .expect("write proof_facts.json");
     std::fs::write(&proof_path, output.proof.0.as_slice()).expect("write proof.bin");
 }
+
+/// Guards against drift between the STRK fee token address used by the proof-flow integration
+/// test and the one produced by the virtual OS test pipeline. Run with `UPDATE_EXPECT=1` to refresh
+/// the constant in `blockifier_test_utils::fee_token_addresses`, then regenerate the proof fixtures
+/// by running `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
+/// starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`.
+#[test]
+fn proof_flow_chain_info_matches_virtual_os_test() {
+    let virtual_os_strk_fee_token_address = block_context_for_flow_tests(BlockNumber(0), false)
+        .chain_info()
+        .fee_token_addresses
+        .strk_fee_token_address;
+    EXPECTED_STRK_FEE_TOKEN_ADDRESS.assert_eq(&virtual_os_strk_fee_token_address.to_hex_string());
+}
+
+/// Guards against drift between the genesis global root the proof-flow integration test seeds into
+/// storage and the initial global root produced by the virtual OS test pipeline. Run with
+/// `UPDATE_EXPECT=1` to refresh the constant in `apollo_integration_tests::state_reader`, then
+/// regenerate the proof fixtures by running `cargo +nightly-2025-07-14 test -p
+/// starknet_os_flow_tests --features starknet_transaction_prover/stwo_proving --release
+/// generate_proof_fixtures -- --ignored`.
+#[tokio::test(flavor = "multi_thread")]
+async fn proof_flow_global_root_matches_virtual_os_test() {
+    let (initial_state_data, []) =
+        create_default_initial_state_data::<DictStateReader, 0>([]).await;
+    let virtual_os_global_root = StateRoots {
+        contracts_trie_root_hash: initial_state_data.initial_state.contracts_trie_root_hash,
+        classes_trie_root_hash: initial_state_data.initial_state.classes_trie_root_hash,
+    }
+    .global_root();
+    EXPECTED_PROOF_FLOW_GENESIS_GLOBAL_ROOT.assert_eq(&virtual_os_global_root.0.to_hex_string());
+}