apollo_integration_tests: add txs with proof

Author: einat-starkware

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

@@ -8,7 +8,8 @@ use tracing::info;
 async fn main() {
     integration_test_setup("positive").await;
     const BLOCK_TO_WAIT_FOR: BlockNumber = BlockNumber(30);
-    const N_INVOKE_TXS: usize = 50;
+    const N_INVOKE_TXS: usize = 25;
+    const N_INVOKE_TXS_WITH_PROOF: usize = 25;
     const N_L1_HANDLER_TXS: usize = 2;
     /// The number of consolidated local sequencers that participate in the test.
     const N_CONSOLIDATED_SEQUENCERS: usize = 3;
@@ -38,7 +39,12 @@ async fn main() {
 
     // Run the test.
     integration_test_manager
-        .send_txs_and_verify(N_INVOKE_TXS, N_L1_HANDLER_TXS, BLOCK_TO_WAIT_FOR)
+        .send_txs_and_verify(
+            N_INVOKE_TXS,
+            N_INVOKE_TXS_WITH_PROOF,
+            N_L1_HANDLER_TXS,
+            BLOCK_TO_WAIT_FOR,
+        )
         .await;
 
     info!("Shutting down nodes.");

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

@@ -15,7 +15,8 @@ async fn main() {
     integration_test_setup("restart_service_multiple_nodes").await;
     const INITIAL_BLOCK_TO_WAIT_FOR: usize = 20;
     const BLOCK_TO_WAIT_FOR_INCREMENT: usize = 5;
-    const N_INVOKE_TXS: usize = 20;
+    const N_INVOKE_TXS: usize = 10;
+    const N_INVOKE_TXS_WITH_PROOF: usize = 10;
     const N_L1_HANDLER_TXS: usize = 1;
     /// The number of consolidated local sequencers that participate in the test.
     const N_CONSOLIDATED_SEQUENCERS: usize = 0;
@@ -72,7 +73,12 @@ async fn main() {
              nodes."
         );
         integration_test_manager
-            .send_txs_and_verify(N_INVOKE_TXS, N_L1_HANDLER_TXS, block_to_wait_for)
+            .send_txs_and_verify(
+                N_INVOKE_TXS,
+                N_INVOKE_TXS_WITH_PROOF,
+                N_L1_HANDLER_TXS,
+                block_to_wait_for,
+            )
             .await;
     }
 

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

@@ -20,7 +20,8 @@ async fn main() {
     assert!(REVERT_UP_TO_AND_INCLUDING < BLOCK_TO_REVERT_FROM);
     assert!(BLOCK_TO_REVERT_FROM < BLOCK_TO_WAIT_FOR_AFTER_REVERT);
 
-    const N_INVOKE_TXS: usize = 50;
+    const N_INVOKE_TXS: usize = 25;
+    const N_INVOKE_TXS_WITH_PROOF: usize = 25;
     const N_L1_HANDLER_TXS: usize = 5;
     /// The number of consolidated local sequencers that participate in the test.
     const N_CONSOLIDATED_SEQUENCERS: usize = 5;
@@ -58,7 +59,12 @@ async fn main() {
 
     info!("Sending transactions and verifying state.");
     integration_test_manager
-        .send_txs_and_verify(N_INVOKE_TXS, N_L1_HANDLER_TXS, BLOCK_TO_REVERT_FROM)
+        .send_txs_and_verify(
+            N_INVOKE_TXS,
+            N_INVOKE_TXS_WITH_PROOF,
+            N_L1_HANDLER_TXS,
+            BLOCK_TO_REVERT_FROM,
+        )
         .await;
 
     info!("Shutting down nodes.");
@@ -113,7 +119,12 @@ async fn main() {
 
     info!("Sending transactions and verifying state.");
     integration_test_manager
-        .send_txs_and_verify(N_INVOKE_TXS, N_L1_HANDLER_TXS, BLOCK_TO_WAIT_FOR_AFTER_REVERT)
+        .send_txs_and_verify(
+            N_INVOKE_TXS,
+            N_INVOKE_TXS_WITH_PROOF,
+            N_L1_HANDLER_TXS,
+            BLOCK_TO_WAIT_FOR_AFTER_REVERT,
+        )
         .await;
 
     integration_test_manager.shutdown_nodes(node_indices);

crates/apollo_integration_tests/src/integration_test_manager.rs

@@ -621,15 +621,16 @@ impl IntegrationTestManager {
     pub async fn send_txs_and_verify(
         &mut self,
         n_invoke_txs: usize,
+        n_invoke_txs_with_proof: usize,
         n_l1_handler_txs: usize,
         wait_for_block: BlockNumber,
     ) {
         info!(
-            "Sending {} invoke + {} l1handler txs and waiting for block {}.",
-            n_invoke_txs, n_l1_handler_txs, wait_for_block
+            "Sending {} invoke + {} invoke with proof + {} l1handler txs and waiting for block {}.",
+            n_invoke_txs, n_invoke_txs_with_proof, n_l1_handler_txs, wait_for_block
         );
         self.test_and_verify(
-            ConsensusTxs { n_invoke_txs, n_l1_handler_txs },
+            ConsensusTxs { n_invoke_txs, n_invoke_txs_with_proof, n_l1_handler_txs },
             DEFAULT_SENDER_ACCOUNT,
             wait_for_block,
         )

crates/apollo_integration_tests/src/sequencer_simulator_utils.rs

@@ -102,7 +102,8 @@ impl SequencerSimulator {
             self.send_txs(
                 tx_generator,
                 &ConsensusTxs {
-                    n_invoke_txs: N_TXS,
+                    n_invoke_txs: N_TXS / 2,
+                    n_invoke_txs_with_proof: N_TXS / 2,
                     // TODO(Arni): Add non-zero value.
                     n_l1_handler_txs: 0,
                 },

crates/apollo_integration_tests/src/utils.rs

@@ -75,7 +75,7 @@ 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::transaction::fields::ContractAddressSalt;
+use starknet_api::transaction::fields::{ContractAddressSalt, Proof, ProofFacts};
 use starknet_api::transaction::{L1HandlerTransaction, TransactionHash, TransactionHasher};
 use starknet_types_core::felt::Felt;
 use tokio::task::JoinHandle;
@@ -110,6 +110,7 @@ pub trait TestScenario {
 
 pub struct ConsensusTxs {
     pub n_invoke_txs: usize,
+    pub n_invoke_txs_with_proof: usize,
     pub n_l1_handler_txs: usize,
 }
 
@@ -120,14 +121,20 @@ impl TestScenario for ConsensusTxs {
         account_id: AccountId,
     ) -> (Vec<RpcTransaction>, Vec<L1HandlerTransaction>) {
         const SHOULD_REVERT: bool = false;
+        let mut invoke_txs = create_invoke_txs(tx_generator, account_id, self.n_invoke_txs);
+        invoke_txs.extend(create_invoke_txs_with_proof(
+            tx_generator,
+            account_id,
+            self.n_invoke_txs_with_proof,
+        ));
         (
-            create_invoke_txs(tx_generator, account_id, self.n_invoke_txs),
+            invoke_txs,
             create_l1_to_l2_messages_args(tx_generator, self.n_l1_handler_txs, SHOULD_REVERT),
         )
     }
 
     fn n_txs(&self) -> usize {
-        self.n_invoke_txs + self.n_l1_handler_txs
+        self.n_invoke_txs + self.n_invoke_txs_with_proof + self.n_l1_handler_txs
     }
 }
 
@@ -527,6 +534,25 @@ pub fn create_invoke_txs(
         .collect()
 }
 
+pub fn create_invoke_txs_with_proof(
+    tx_generator: &mut MultiAccountTransactionGenerator,
+    account_id: AccountId,
+    n_txs: usize,
+) -> Vec<RpcTransaction> {
+    (0_u64..)
+        .take(n_txs)
+        .map(|i| {
+            tx_generator.account_with_id_mut(account_id).generate_trivial_rpc_invoke_tx_with_proof(
+                1,
+                // Use unique proof facts for each transaction to ensure proper proof
+                // storage/retrieval.
+                ProofFacts::snos_proof_facts_for_testing_with_index(i),
+                Proof::proof_for_testing(),
+            )
+        })
+        .collect()
+}
+
 pub fn create_l1_to_l2_messages_args(
     tx_generator: &mut MultiAccountTransactionGenerator,
     n_txs: usize,
@@ -622,6 +648,7 @@ pub fn create_gateway_config(
         validate_resource_bounds: validate_non_zero_resource_bounds,
         max_calldata_length: 19,
         max_signature_length: 2,
+        allow_client_side_proving: true,
         ..Default::default()
     };
     let stateful_tx_validator_config = StatefulTransactionValidatorConfig {

crates/mempool_test_utils/src/starknet_api_test_utils.rs

@@ -403,6 +403,24 @@ impl AccountTransactionGenerator {
         rpc_invoke_tx(self.build_invoke_tx_args().tip(Tip(tip)).calldata(calldata))
     }
 
+    /// Generates a trivial invoke transaction with proof facts and proof for client-side proving.
+    pub fn generate_trivial_rpc_invoke_tx_with_proof(
+        &mut self,
+        tip: u64,
+        proof_facts: ProofFacts,
+        proof: Proof,
+    ) -> RpcTransaction {
+        let test_contract = FeatureContract::TestContract(self.account.cairo_version());
+        let calldata = create_trivial_calldata(test_contract.get_instance_address(0));
+        rpc_invoke_tx(
+            self.build_invoke_tx_args()
+                .tip(Tip(tip))
+                .calldata(calldata)
+                .proof_facts(proof_facts)
+                .proof(proof),
+        )
+    }
+
     fn generate_nested_call_invoke_tx(
         &mut self,
         outer_test_contract: &FeatureContract,

crates/starknet_api/src/test_utils.rs

@@ -381,9 +381,12 @@ impl ProofFacts {
     ///
     /// See [`crate::transaction::fields::ProofFacts`].
     pub fn snos_proof_facts_for_testing() -> Self {
+        Self::snos_proof_facts_for_testing_with_index(0)
+    }
+    pub fn snos_proof_facts_for_testing_with_index(index: u64) -> Self {
         let block_hash_history_start = CURRENT_BLOCK_NUMBER - BLOCK_HASH_HISTORY_RANGE;
         let block_number = felt!(block_hash_history_start + 2);
-        let block_hash = block_number * felt!(100_u64);
+        let block_hash = block_number * felt!(100_u64) + felt!(index);
         assert!(
             block_number < felt!(CURRENT_BLOCK_NUMBER)
                 && block_number >= felt!(block_hash_history_start),

crates/starknet_api/src/test_utils/invoke.rs

@@ -227,4 +227,14 @@ impl InvokeTxArgs {
         self.nonce = nonce;
         self
     }
+
+    pub fn proof_facts(mut self, proof_facts: ProofFacts) -> Self {
+        self.proof_facts = proof_facts;
+        self
+    }
+
+    pub fn proof(mut self, proof: Proof) -> Self {
+        self.proof = proof;
+        self
+    }
 }