Add a integration test on the prover in mithril-aggregator

Alenar · Alenar · commit 571ccb91b890 · 2024-07-04T16:14:40.000+02:00
diff --git a/mithril-aggregator/tests/prove_transactions.rs b/mithril-aggregator/tests/prove_transactions.rs
@@ -0,0 +1,149 @@
+use mithril_aggregator::Configuration;
+use mithril_common::{
+    entities::{
+        CardanoDbBeacon, CardanoTransactionsSigningConfig, ChainPoint, Epoch,
+        ProtocolMessagePartKey, ProtocolParameters, SignedEntityType,
+        SignedEntityTypeDiscriminants, TimePoint,
+    },
+    test_utils::MithrilFixtureBuilder,
+};
+use test_extensions::{utilities::get_test_dir, ExpectedCertificate, RuntimeTester};
+
+use crate::test_extensions::utilities::tx_hash;
+
+mod test_extensions;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn prove_transactions() {
+    let protocol_parameters = ProtocolParameters {
+        k: 5,
+        m: 150,
+        phi_f: 0.95,
+    };
+    let configuration = Configuration {
+        protocol_parameters: protocol_parameters.clone(),
+        signed_entity_types: Some(SignedEntityTypeDiscriminants::CardanoTransactions.to_string()),
+        data_stores_directory: get_test_dir("prove_transactions"),
+        cardano_transactions_signing_config: CardanoTransactionsSigningConfig {
+            security_parameter: 0,
+            step: 30,
+        },
+        ..Configuration::new_sample()
+    };
+    let mut tester = RuntimeTester::build(
+        TimePoint {
+            epoch: Epoch(1),
+            immutable_file_number: 1,
+            chain_point: ChainPoint {
+                slot_number: 10,
+                block_number: 100,
+                block_hash: "block_hash-100".to_string(),
+            },
+        },
+        configuration,
+    )
+    .await;
+    let observer = tester.observer.clone();
+    let prover = tester.dependencies.prover_service.clone();
+
+    comment!("create signers & declare stake distribution");
+    let fixture = MithrilFixtureBuilder::default()
+        .with_signers(10)
+        .with_protocol_parameters(protocol_parameters.clone())
+        .build();
+    let signers = &fixture.signers_fixture();
+
+    tester.init_state_from_fixture(&fixture).await.unwrap();
+
+    comment!("Boostrap the genesis certificate");
+    tester.register_genesis_certificate(&fixture).await.unwrap();
+
+    assert_last_certificate_eq!(
+        tester,
+        ExpectedCertificate::new_genesis(
+            CardanoDbBeacon::new("devnet", 1, 1),
+            fixture.compute_and_encode_avk()
+        )
+    );
+
+    // Lock all signed entity types except CardanoTransactions to limit the scope of the test
+    for entity in SignedEntityTypeDiscriminants::all()
+        .into_iter()
+        .filter(|e| e != &SignedEntityTypeDiscriminants::CardanoTransactions)
+    {
+        tester
+            .dependencies
+            .signed_entity_type_lock
+            .lock(entity)
+            .await;
+    }
+
+    comment!("register signers");
+    cycle!(tester, "ready");
+    tester
+        .register_signers(&fixture.signers_fixture())
+        .await
+        .unwrap();
+
+    comment!(
+        "Increase cardano chain block number to 185, 
+        the state machine should be signing CardanoTransactions up to block 179 included"
+    );
+    tester.increase_block_number(85, 185).await.unwrap();
+    cycle!(tester, "signing");
+    tester
+        .send_single_signatures(SignedEntityTypeDiscriminants::CardanoTransactions, signers)
+        .await
+        .unwrap();
+
+    comment!("The state machine should issue a certificate for the CardanoTransactions");
+    cycle!(tester, "ready");
+    assert_last_certificate_eq!(
+        tester,
+        ExpectedCertificate::new(
+            CardanoDbBeacon::new("devnet", 1, 1),
+            &signers
+                .iter()
+                .map(|s| s.signer_with_stake.clone().into())
+                .collect::<Vec<_>>(),
+            fixture.compute_and_encode_avk(),
+            SignedEntityType::CardanoTransactions(Epoch(1), 179),
+            ExpectedCertificate::genesis_identifier(&CardanoDbBeacon::new("devnet", 1, 1)),
+        )
+    );
+
+    cycle!(tester, "ready");
+
+    comment!("Get the proof for the last transaction, BlockNumber(179), and verify it");
+    let last_transaction_hash = tx_hash(179, 1);
+    let last_tx_snapshot = observer
+        .get_last_cardano_transactions_snapshot()
+        .await
+        .unwrap();
+    let proof_for_last_transaction = prover
+        .compute_transactions_proofs(
+            last_tx_snapshot.artifact.block_number,
+            &[last_transaction_hash.clone()],
+        )
+        .await
+        .unwrap()
+        .pop()
+        .unwrap();
+    assert!(proof_for_last_transaction
+        .transactions_hashes()
+        .contains(&last_transaction_hash));
+
+    proof_for_last_transaction.verify().unwrap();
+
+    comment!("Get the certificate associated with the last transaction and check that it matches the proof");
+    let proof_merkle_root = proof_for_last_transaction.merkle_root();
+    let proof_certificate = observer.get_last_certificate().await.unwrap();
+    assert_eq!(&last_tx_snapshot.certificate_id, &proof_certificate.hash);
+    assert_eq!(
+        proof_certificate
+            .protocol_message
+            .get_message_part(&ProtocolMessagePartKey::CardanoTransactionsMerkleRoot),
+        Some(&proof_merkle_root),
+        "The proof merkle root should match the one in the certificate"
+    );
+}
diff --git a/mithril-aggregator/tests/test_extensions/aggregator_observer.rs b/mithril-aggregator/tests/test_extensions/aggregator_observer.rs
@@ -1,7 +1,9 @@
 use anyhow::{anyhow, Context};
+use mithril_aggregator::services::SignedEntityService;
 use mithril_aggregator::{
     dependency_injection::DependenciesBuilder, entities::OpenMessage, services::CertifierService,
 };
+use mithril_common::entities::{CardanoTransactionsSnapshot, Certificate, SignedEntity};
 use mithril_common::{
     entities::{
         Epoch, SignedEntityConfig, SignedEntityType, SignedEntityTypeDiscriminants, TimePoint,
@@ -14,6 +16,7 @@ use std::sync::Arc;
 pub struct AggregatorObserver {
     network: CardanoNetwork,
     certifier_service: Arc<dyn CertifierService>,
+    signed_entity_service: Arc<dyn SignedEntityService>,
     ticker_service: Arc<dyn TickerService>,
     signed_entity_config: SignedEntityConfig,
 }
@@ -24,6 +27,7 @@ impl AggregatorObserver {
         Self {
             network: deps_builder.configuration.get_network().unwrap(),
             certifier_service: deps_builder.get_certifier_service().await.unwrap(),
+            signed_entity_service: deps_builder.get_signed_entity_service().await.unwrap(),
             ticker_service: deps_builder.get_ticker_service().await.unwrap(),
             signed_entity_config: deps_builder.get_signed_entity_config().unwrap(),
         }
@@ -52,7 +56,7 @@ impl AggregatorObserver {
             .with_context(|| "Requesting current open message of type CardanoImmutableFilesFull should be not fail")
     }
 
-    // Get the [entity type][SignedEntityType::CardanoImmutableFilesFull] of the current current open message
+    /// Get the [entity type][SignedEntityType::CardanoImmutableFilesFull] of the current current open message
     pub async fn get_current_signed_entity_type(
         &self,
         discriminant: SignedEntityTypeDiscriminants,
@@ -65,6 +69,35 @@ impl AggregatorObserver {
         }
     }
 
+    /// Get the last certificate produced by the aggregator
+    pub async fn get_last_certificate(&self) -> StdResult<Certificate> {
+        let certificate = self
+            .certifier_service
+            .get_latest_certificates(1)
+            .await
+            .with_context(|| "Querying last certificate should not fail")?
+            .pop()
+            .ok_or(anyhow!(
+                "No certificate have been produced by the aggregator"
+            ))?;
+        Ok(certificate)
+    }
+
+    /// Get the last cardano transactions snapshot produced by the aggregator
+    pub async fn get_last_cardano_transactions_snapshot(
+        &self,
+    ) -> StdResult<SignedEntity<CardanoTransactionsSnapshot>> {
+        let last_tx_snapshot = self
+            .signed_entity_service
+            .get_last_cardano_transaction_snapshot()
+            .await
+            .with_context(|| "Querying last cardano transactions snapshot should not fail")?
+            .ok_or(anyhow!(
+                "No cardano transactions snapshot have been produced by the aggregator"
+            ))?;
+        Ok(last_tx_snapshot)
+    }
+
     async fn build_current_signed_entity_type(
         &self,
         discriminant: SignedEntityTypeDiscriminants,
diff --git a/mithril-aggregator/tests/test_extensions/runtime_tester.rs b/mithril-aggregator/tests/test_extensions/runtime_tester.rs
@@ -1,3 +1,5 @@
+use crate::test_extensions::utilities::tx_hash;
+use crate::test_extensions::{AggregatorObserver, ExpectedCertificate};
 use anyhow::{anyhow, Context};
 use chrono::Utc;
 use mithril_aggregator::{
@@ -28,8 +30,6 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc::UnboundedReceiver;
 
-use crate::test_extensions::{AggregatorObserver, ExpectedCertificate};
-
 #[macro_export]
 macro_rules! cycle {
     ( $tester:expr, $expected_state:expr ) => {{
@@ -276,7 +276,7 @@ impl RuntimeTester {
                     block_number,
                     slot_number,
                     current_immutable,
-                    vec![format!("tx_hash-{block_number}-1")],
+                    vec![tx_hash(block_number, 1)],
                 )
             })
             .collect();
@@ -485,17 +485,7 @@ impl RuntimeTester {
     pub async fn get_last_certificate_with_signed_entity(
         &mut self,
     ) -> StdResult<(Certificate, Option<SignedEntityRecord>)> {
-        let certificate = self
-            .dependencies
-            .certifier_service
-            .get_latest_certificates(1)
-            .await
-            .with_context(|| "Querying last certificate should not fail")?
-            .first()
-            .ok_or(anyhow!(
-                "No certificate have been produced by the aggregator"
-            ))?
-            .clone();
+        let certificate = self.observer.get_last_certificate().await?;
 
         let signed_entity = match &certificate.signature {
             CertificateSignature::GenesisSignature(..) => None,
diff --git a/mithril-aggregator/tests/test_extensions/utilities.rs b/mithril-aggregator/tests/test_extensions/utilities.rs
@@ -1,3 +1,4 @@
+use mithril_common::entities::BlockNumber;
 use mithril_common::test_utils::TempDir;
 use slog_scope::debug;
 use std::{
@@ -19,6 +20,10 @@ pub fn comment(comment: String) {
     debug!("COMMENT {:02} 💬 {}", old_count + 1, comment);
 }
 
+pub fn tx_hash(block_number: BlockNumber, tx_index: u64) -> String {
+    format!("tx_hash-{block_number}-{tx_index}")
+}
+
 #[macro_export]
 macro_rules! comment {
     ( $($comment:tt)* ) => {{
