apollo_integration_tests: add proof flow integration test (#13950)

Author: einat-starkware

crates/apollo_integration_tests/Cargo.toml

@@ -95,6 +95,10 @@ metrics.workspace = true
 mockall.workspace = true
 rstest.workspace = true
 
+[[bin]]
+name = "integration_test_proof_flow"
+path = "src/bin/sequencer_node_end_to_end_integration_tests/integration_test_proof_flow.rs"
+
 [[bin]]
 name = "integration_test_positive_flow"
 path = "src/bin/sequencer_node_end_to_end_integration_tests/integration_test_positive_flow.rs"

crates/apollo_integration_tests/src/bin/sequencer_node_end_to_end_integration_tests/integration_test_proof_flow.rs

@@ -0,0 +1,54 @@
+//! Integration test for the proof submission flow.
+//!
+//! The test relies on pre-generated fixture files in
+//! `crates/apollo_integration_tests/resources/proof_flow/`.
+
+use apollo_infra_utils::test_utils::TestIdentifier;
+use apollo_integration_tests::integration_test_manager::{
+    IntegrationTestManager,
+    DEFAULT_SENDER_ACCOUNT,
+};
+use apollo_integration_tests::integration_test_utils::integration_test_setup;
+use apollo_integration_tests::utils::ProofFlowTxs;
+use blockifier::abi::constants::STORED_BLOCK_HASH_BUFFER;
+use starknet_api::block::BlockNumber;
+use tracing::info;
+
+#[tokio::main]
+async fn main() {
+    integration_test_setup("proof_flow").await;
+
+    // The fixture's proof references block 0, so the proof-bearing tx is only valid once the
+    // chain has progressed past `STORED_BLOCK_HASH_BUFFER`. We first advance the chain past that
+    // buffer with filler invokes, then submit the proof tx and wait one more block.
+    const BLOCK_PAST_HASH_BUFFER: BlockNumber = BlockNumber(STORED_BLOCK_HASH_BUFFER);
+    const BLOCK_TO_WAIT_FOR: BlockNumber = BlockNumber(STORED_BLOCK_HASH_BUFFER + 1);
+    const N_CONSOLIDATED_SEQUENCERS: usize = 1;
+    const N_DISTRIBUTED_SEQUENCERS: usize = 1;
+    const N_HYBRID_SEQUENCERS: usize = 1;
+
+    let mut integration_test_manager = IntegrationTestManager::new(
+        N_CONSOLIDATED_SEQUENCERS,
+        N_DISTRIBUTED_SEQUENCERS,
+        N_HYBRID_SEQUENCERS,
+        None,
+        TestIdentifier::ProofFlowIntegrationTest,
+    )
+    .await;
+
+    let node_indices = integration_test_manager.get_node_indices();
+    integration_test_manager.run_nodes(node_indices.clone()).await;
+
+    integration_test_manager.send_deploy_and_invoke_txs_and_verify().await;
+
+    integration_test_manager.await_block_on_all_running_nodes(BLOCK_PAST_HASH_BUFFER).await;
+
+    integration_test_manager
+        .test_and_verify(ProofFlowTxs::new(), DEFAULT_SENDER_ACCOUNT, BLOCK_TO_WAIT_FOR)
+        .await;
+
+    info!("Shutting down nodes.");
+    integration_test_manager.shutdown_nodes(node_indices);
+
+    info!("Proof flow integration test completed successfully!");
+}

crates/apollo_integration_tests/src/integration_test_manager.rs

@@ -874,7 +874,7 @@ impl IntegrationTestManager {
 
     /// Waits until all running nodes reach the specified block number.
     /// Queries the batcher and state sync metrics to verify progress.
-    async fn await_block_on_all_running_nodes(&self, expected_block_number: BlockNumber) {
+    pub async fn await_block_on_all_running_nodes(&self, expected_block_number: BlockNumber) {
         self.perform_action_on_all_running_nodes(|running_node| {
             let node_setup = &running_node.node_setup;
             let batcher_monitoring_client = node_setup.batcher_monitoring_client();

crates/apollo_integration_tests/src/utils.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::future::Future;
 use std::net::{Ipv4Addr, SocketAddr};
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::Duration;
 
 use apollo_base_layer_tests::anvil_base_layer::AnvilBaseLayer;
@@ -117,9 +118,9 @@ use serde_json::{json, to_value};
 use starknet_api::block::BlockNumber;
 use starknet_api::core::{ChainId, ContractAddress};
 use starknet_api::execution_resources::GasAmount;
-use starknet_api::rpc_transaction::RpcTransaction;
+use starknet_api::rpc_transaction::{RpcInvokeTransaction, RpcTransaction};
 use starknet_api::staking::StakingWeight;
-use starknet_api::transaction::fields::ContractAddressSalt;
+use starknet_api::transaction::fields::{ContractAddressSalt, Proof, ProofFacts};
 use starknet_api::transaction::{L1HandlerTransaction, TransactionHash, TransactionHasher};
 use starknet_committer::db::forest_trait::{
     ForestMetadata,
@@ -231,6 +232,57 @@ impl TestScenario for DeployAndInvokeTxs {
     }
 }
 
+fn load_proof_flow_proof_facts() -> ProofFacts {
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/resources/proof_flow/proof_facts.json");
+    let json = std::fs::read_to_string(path)
+        .expect("Failed to read proof_facts.json — run the fixture generator first");
+    serde_json::from_str(&json).expect("Failed to parse proof_facts.json")
+}
+
+fn load_proof_flow_proof() -> Proof {
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/resources/proof_flow/proof.bin");
+    let bytes =
+        std::fs::read(path).expect("Failed to read proof.bin — run the fixture generator first");
+    Proof(Arc::new(bytes))
+}
+
+pub struct ProofFlowTxs {
+    proof_facts: ProofFacts,
+    proof: Proof,
+}
+
+impl Default for ProofFlowTxs {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ProofFlowTxs {
+    pub fn new() -> Self {
+        Self { proof_facts: load_proof_flow_proof_facts(), proof: load_proof_flow_proof() }
+    }
+}
+
+impl TestScenario for ProofFlowTxs {
+    fn create_txs(
+        &self,
+        tx_generator: &mut MultiAccountTransactionGenerator,
+        account_id: AccountId,
+    ) -> (Vec<RpcTransaction>, Vec<L1HandlerTransaction>) {
+        let tx = tx_generator.account_with_id_mut(account_id).generate_trivial_rpc_invoke_tx(1);
+        let RpcTransaction::Invoke(RpcInvokeTransaction::V3(mut inner)) = tx else {
+            panic!("Expected RpcInvokeTransactionV3")
+        };
+        inner.proof_facts = self.proof_facts.clone();
+        inner.proof = self.proof.clone();
+        (vec![RpcTransaction::Invoke(RpcInvokeTransaction::V3(inner))], vec![])
+    }
+
+    fn n_txs(&self) -> usize {
+        1
+    }
+}
+
 // TODO(Tsabary): clean the passed args.
 #[allow(clippy::too_many_arguments)]
 pub fn create_node_config(

scripts/run_tests.py

@@ -27,6 +27,7 @@
     "integration_test_positive_flow",
     "integration_test_restart_service_multiple_nodes_flow",
     "integration_test_revert_flow",
+    "integration_test_proof_flow",
 ]
 NIGHTLY_ONLY_SEQUENCER_INTEGRATION_TEST_NAMES: List[str] = [
     # TODO(AndrewL): Try adding these tests to CI as well

scripts/sequencer_integration_test.sh

@@ -26,6 +26,7 @@ declare -A TEST_ALIASES=(
   [restart_single_node]="integration_test_restart_service_single_node_flow"
   [revert]="integration_test_revert_flow"
   [sync]="integration_test_central_and_p2p_sync_flow"
+  [proof]="integration_test_proof_flow"
 )
 
 # Set default test if none provided