starknet_os_flow_tests: generate proof fixtures for the integration tests (#13781)

Author: einat-starkware

Cargo.lock

@@ -0,0 +1,10 @@
+[
+  "0x50524f4f4630",
+  "0x5649525455414c5f534e4f53",
+  "0x3e98c2d7703b03a7edb73ed7f075f97f1dcbaa8f717cdf6e1a57bf058265473",
+  "0x5649525455414c5f534e4f5330",
+  "0x0",
+  "0x3dca758e4b12ec76dae108bd909d6783b3193a427a2f8f7c86d257ac225e384",
+  "0xa076790848f1f566e0ea5d75fd38cca24de30337471171f480c7f16fe33d42",
+  "0x0"
+]

crates/apollo_integration_tests/resources/proof_flow/proof.bin

@@ -12,6 +12,7 @@ fuzz_test_debug = []
 long_fuzz_test = []
 
 [dev-dependencies]
+apollo_integration_tests.workspace = true
 assert_matches.workspace = true
 blockifier = { workspace = true, features = ["reexecution", "testing"] }
 blockifier_test_utils.workspace = true

crates/apollo_integration_tests/resources/proof_flow/proof_facts.json

@@ -992,6 +992,23 @@ impl TestBuilder<DictStateReader> {
         Self::new_with_default_initial_state(extra_contracts, TestBuilderConfig::default(), true)
             .await
     }
+
+    /// Virtual OS builder that overrides the block context.
+    pub(crate) async fn create_virtual_with_block_info(
+        block_info: BlockInfo,
+        config: TestBuilderConfig,
+    ) -> Self {
+        let (mut initial_state_data, []) =
+            create_default_initial_state_data::<DictStateReader, 0>([]).await;
+        let block_context = &initial_state_data.initial_state.block_context;
+        initial_state_data.initial_state.block_context = BlockContext::new(
+            block_info,
+            block_context.chain_info().clone(),
+            block_context.versioned_constants().clone(),
+            block_context.bouncer_config.clone(),
+        );
+        Self::new_with_initial_state_data(initial_state_data, config, true)
+    }
 }
 
 /// Returns a BlockContext of the given block number with the with the STRK fee token address that

crates/starknet_os_flow_tests/Cargo.toml

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use blockifier::execution::contract_class::TrackedResource;
 use blockifier::test_utils::dict_state_reader::DictStateReader;
 use blockifier::test_utils::get_valid_virtual_os_program_hash;
@@ -7,7 +9,7 @@ use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
 use rstest::rstest;
 use starknet_api::abi::abi_utils::selector_from_name;
-use starknet_api::block::BlockTimestamp;
+use starknet_api::block::{BlockInfo, BlockNumber, BlockTimestamp};
 use starknet_api::core::EthAddress;
 use starknet_api::test_utils::{CURRENT_BLOCK_TIMESTAMP, TEST_SEQUENCER_ADDRESS};
 use starknet_api::transaction::fields::{ProofFacts, TransactionSignature};
@@ -271,3 +273,38 @@ async fn test_reverted_tx_os_error() {
         .await
         .run_virtual_expect_error("Reverted transactions are not supported in virtual OS mode");
 }
+
+/// Generates proof fixtures for the proof-flow integration test.
+/// To run manually: `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")]
+#[ignore]
+async fn generate_proof_fixtures() {
+    let block_info = BlockInfo {
+        block_number: BlockNumber(0),
+        block_timestamp: BlockTimestamp(0),
+        ..BlockInfo::create_for_testing()
+    };
+    let mut test_builder = TestBuilder::<DictStateReader>::create_virtual_with_block_info(
+        block_info,
+        TestBuilderConfig::default(),
+    )
+    .await;
+
+    test_builder.add_fund_address_tx_with_default_amount(*FUNDED_ACCOUNT_ADDRESS);
+
+    let test_runner = test_builder.build().await;
+    let output = test_runner.run_virtual().prove().await;
+
+    let fixtures_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("../apollo_integration_tests/resources/proof_flow");
+    std::fs::create_dir_all(&fixtures_dir).expect("create proof_flow dir");
+    let proof_facts_path = fixtures_dir.join("proof_facts.json");
+    let proof_path = fixtures_dir.join("proof.bin");
+    std::fs::write(
+        &proof_facts_path,
+        serde_json::to_string_pretty(&output.proof_facts).expect("serialize proof_facts"),
+    )
+    .expect("write proof_facts.json");
+    std::fs::write(&proof_path, output.proof.0.as_slice()).expect("write proof.bin");
+}

crates/starknet_os_flow_tests/src/test_manager.rs

@@ -1,10 +1,16 @@
 use starknet_api::transaction::fields::VIRTUAL_OS_OUTPUT_VERSION;
+use starknet_api::transaction::MessageToL1;
 use starknet_os::io::virtual_os_output::{
     compute_messages_to_l1_hashes,
     VirtualOsOutput,
     VirtualOsRunnerOutput,
 };
 use starknet_os::runner::run_virtual_os;
+use starknet_transaction_prover::proving::virtual_snos_prover::{
+    prove_virtual_snos_run,
+    ProveTransactionResult,
+};
+use starknet_transaction_prover::running::runner::RunnerOutput;
 
 use crate::initial_state::FlowTestState;
 use crate::test_manager::TestRunner;
@@ -15,6 +21,8 @@ pub(crate) struct VirtualOsTestOutput {
     pub(crate) runner_output: VirtualOsRunnerOutput,
     /// The expected values computed from the OS hints.
     pub(crate) expected_virtual_os_output: VirtualOsOutput,
+    /// The messages sent from L2 to L1 during execution.
+    pub(crate) messages_to_l1: Vec<MessageToL1>,
     // TODO(Yoni): consider adding more data for sanity checks, such as the expected state diff.
 }
 
@@ -26,6 +34,13 @@ impl VirtualOsTestOutput {
 
         assert_eq!(virtual_os_output, self.expected_virtual_os_output);
     }
+    pub(crate) async fn prove(self) -> ProveTransactionResult {
+        let runner_output = RunnerOutput {
+            cairo_pie: self.runner_output.cairo_pie,
+            l2_to_l1_messages: self.messages_to_l1,
+        };
+        prove_virtual_snos_run(runner_output).await.expect("Proving virtual OS should not fail.")
+    }
 }
 
 impl<S: FlowTestState> TestRunner<S> {
@@ -38,6 +53,7 @@ impl<S: FlowTestState> TestRunner<S> {
             self.os_hints.os_hints_config.chain_info.compute_virtual_os_config_hash().unwrap();
 
         let messages_to_l1_hashes = compute_messages_to_l1_hashes(&self.messages_to_l1);
+        let messages_to_l1 = self.messages_to_l1;
         let expected_virtual_os_output = VirtualOsOutput {
             version: VIRTUAL_OS_OUTPUT_VERSION,
             base_block_number: first_block.block_info.block_number,
@@ -50,7 +66,7 @@ impl<S: FlowTestState> TestRunner<S> {
         let runner_output =
             run_virtual_os(self.os_hints).expect("Running virtual OS should not fail.");
 
-        VirtualOsTestOutput { runner_output, expected_virtual_os_output }
+        VirtualOsTestOutput { runner_output, expected_virtual_os_output, messages_to_l1 }
     }
 
     /// Runs the virtual OS and validates the output against expected values.

crates/starknet_os_flow_tests/src/virtual_os_test.rs

@@ -47,7 +47,7 @@ pub struct ProveTransactionResult {
 /// The prover is generic over the runner, allowing different implementations
 /// (RPC-based, mock, etc.) to be used interchangeably.
 #[derive(Clone)]
-pub(crate) struct VirtualSnosProver<R: VirtualSnosRunner> {
+pub struct VirtualSnosProver<R: VirtualSnosRunner> {
     /// Runner for executing the virtual OS.
     runner: R,
     /// Whether to validate that fee-related fields (resource bounds, tip) are zero.
@@ -60,7 +60,7 @@ pub(crate) struct VirtualSnosProver<R: VirtualSnosRunner> {
 }
 
 /// Type alias for the RPC-based virtual SNOS prover.
-pub(crate) type RpcVirtualSnosProver = VirtualSnosProver<RpcRunnerFactory>;
+pub type RpcVirtualSnosProver = VirtualSnosProver<RpcRunnerFactory>;
 
 impl VirtualSnosProver<RpcRunnerFactory> {
     /// Creates a new VirtualSnosProver from configuration.
@@ -292,24 +292,51 @@ impl<R: VirtualSnosRunner + 'static> VirtualSnosProver<R> {
     /// Generates a proof from the given [`RunnerOutput`] and converts the program output into
     /// proof facts.
     #[cfg(feature = "stwo_proving")]
-    async fn prove_virtual_snos_run(
+    pub async fn prove_virtual_snos_run(
         &self,
         runner_output: RunnerOutput,
     ) -> Result<ProveTransactionResult, VirtualSnosProverError> {
-        use starknet_api::transaction::fields::VIRTUAL_SNOS;
+        prove_virtual_snos_run_with_precomputes(runner_output, self.precomputes.clone()).await
+    }
+}
+
+/// Proves a Virtual Starknet OS run fdirectly from a `RunnerOutput`.
+#[cfg(feature = "stwo_proving")]
+pub async fn prove_virtual_snos_run(
+    runner_output: RunnerOutput,
+) -> Result<ProveTransactionResult, VirtualSnosProverError> {
+    let precomputes = prepare_recursive_prover_precomputes()
+        .expect("Failed to prepare recursive prover precomputes");
+    prove_virtual_snos_run_with_precomputes(runner_output, precomputes).await
+}
 
-        use crate::proving::prover::prove;
+#[cfg(not(feature = "stwo_proving"))]
+pub async fn prove_virtual_snos_run(
+    _runner_output: RunnerOutput,
+) -> Result<ProveTransactionResult, VirtualSnosProverError> {
+    unimplemented!(
+        "In-memory proving requires the `stwo_proving` feature flag and a nightly Rust toolchain."
+    );
+}
+
+#[cfg(feature = "stwo_proving")]
+async fn prove_virtual_snos_run_with_precomputes(
+    runner_output: RunnerOutput,
+    precomputes: Arc<RecursiveProverPrecomputes>,
+) -> Result<ProveTransactionResult, VirtualSnosProverError> {
+    use starknet_api::transaction::fields::VIRTUAL_SNOS;
 
-        let prover_output = prove(runner_output.cairo_pie, self.precomputes.clone()).await?;
-        // Convert program output to proof facts using VIRTUAL_SNOS variant marker.
-        let proof_facts = prover_output.program_output.try_into_proof_facts(VIRTUAL_SNOS)?;
+    use crate::proving::prover::prove;
 
-        Ok(ProveTransactionResult {
-            proof: prover_output.proof,
-            proof_facts,
-            l2_to_l1_messages: runner_output.l2_to_l1_messages,
-        })
-    }
+    let prover_output = prove(runner_output.cairo_pie, precomputes).await?;
+    // Convert program output to proof facts using VIRTUAL_SNOS variant marker.
+    let proof_facts = prover_output.program_output.try_into_proof_facts(VIRTUAL_SNOS)?;
+
+    Ok(ProveTransactionResult {
+        proof: prover_output.proof,
+        proof_facts,
+        l2_to_l1_messages: runner_output.l2_to_l1_messages,
+    })
 }
 
 /// Extracts the RPC Invoke V3 transaction, rejecting other transaction types.

crates/starknet_os_flow_tests/src/virtual_os_test_manager.rs

@@ -338,7 +338,7 @@ where
 /// allowing different runner implementations (RPC-based, mock, etc.) to be used
 /// interchangeably.
 #[async_trait]
-pub(crate) trait VirtualSnosRunner: Clone + Send + Sync {
+pub trait VirtualSnosRunner: Clone + Send + Sync {
     /// Runs the Starknet virtual OS with the given transactions on top of the specified block.
     async fn run_virtual_os(
         &self,
@@ -379,7 +379,7 @@ pub(crate) type RpcRunner = Runner<
 /// let output = runner.run_virtual_os(txs).await?;
 /// ```
 #[derive(Clone)]
-pub(crate) struct RpcRunnerFactory {
+pub struct RpcRunnerFactory {
     /// URL of the RPC node.
     node_url: Url,
     chain_info: ChainInfo,