refactor(client-lib): remove compute_merkle_proof since logic is moved to compute_cardano_database_message

Author: turmelclem

mithril-client-cli/src/commands/cardano_db/download/v2.rs

@@ -139,18 +139,6 @@ impl PreparedCardanoDbV2Download {
             )
         })?;
 
-        // let merkle_proof = shared_steps::compute_verify_merkle_proof(
-        //     5,
-        //     &progress_printer,
-        //     &client,
-        //     &certificate,
-        //     &cardano_db_message,
-        //     &restoration_options.immutable_file_range,
-        //     &restoration_options.db_dir,
-        //     &verified_digests,
-        // )
-        // .await?;
-
         let message = shared_steps::compute_cardano_db_snapshot_message(
             5,
             &progress_printer,

mithril-client-cli/src/commands/cardano_db/shared_steps.rs

@@ -6,7 +6,7 @@ use std::path::Path;
 use mithril_client::{
     CardanoDatabaseSnapshot, Client, MessageBuilder, MithrilCertificate, MithrilResult,
     cardano_database_client::{ImmutableFileRange, VerifiedDigests},
-    common::{ImmutableFileNumber, MKProof, ProtocolMessage},
+    common::{ImmutableFileNumber, ProtocolMessage},
 };
 
 use crate::utils::{CardanoDbUtils, ProgressPrinter};
@@ -63,36 +63,6 @@ pub async fn download_and_verify_digests(
     Ok(verified_digests)
 }
 
-/// Computes and verifies the Merkle proof for the given certificate and database snapshot.
-pub async fn compute_verify_merkle_proof(
-    step_number: u16,
-    progress_printer: &ProgressPrinter,
-    client: &Client,
-    certificate: &MithrilCertificate,
-    cardano_database_snapshot: &CardanoDatabaseSnapshot,
-    immutable_file_range: &ImmutableFileRange,
-    unpacked_dir: &Path,
-    verified_digests: &VerifiedDigests,
-) -> MithrilResult<MKProof> {
-    progress_printer.report_step(step_number, "Computing and verifying the Merkle proof…")?;
-    let merkle_proof = client
-        .cardano_database_v2()
-        .compute_merkle_proof(
-            certificate,
-            cardano_database_snapshot.beacon.immutable_file_number,
-            immutable_file_range,
-            Path::new(&unpacked_dir),
-            verified_digests,
-        )
-        .await?;
-
-    merkle_proof
-        .verify()
-        .with_context(|| "Merkle proof verification failed")?;
-
-    Ok(merkle_proof)
-}
-
 /// Computes the Cardano database snapshot message using the provided certificate and Merkle proof.
 pub async fn compute_cardano_db_snapshot_message(
     step_number: u16,

mithril-client-cli/src/commands/cardano_db/verify.rs

@@ -113,18 +113,6 @@ impl CardanoDbVerifyCommand {
         )
         .await?;
 
-        // let merkle_proof = shared_steps::compute_verify_merkle_proof(
-        //     3,
-        //     &progress_printer,
-        //     &client,
-        //     &certificate,
-        //     &cardano_db_message,
-        //     &immutable_file_range,
-        //     db_dir,
-        //     &verified_digests,
-        // )
-        // .await?;
-
         let message = shared_steps::compute_cardano_db_snapshot_message(
             3,
             &progress_printer,

mithril-client/src/cardano_database_client/api.rs

@@ -6,11 +6,7 @@ use std::sync::Arc;
 use slog::Logger;
 
 #[cfg(feature = "fs")]
-use mithril_common::{
-    crypto_helper::MKProof,
-    entities::ImmutableFileNumber,
-    messages::{CardanoDatabaseSnapshotMessage, CertificateMessage},
-};
+use mithril_common::messages::{CardanoDatabaseSnapshotMessage, CertificateMessage};
 
 #[cfg(feature = "fs")]
 use mithril_cardano_node_internal_database::entities::ImmutableFile;
@@ -115,27 +111,6 @@ impl CardanoDatabaseClient {
             .await
     }
 
-    /// Compute the Merkle proof of membership for the given immutable file range.
-    #[cfg(feature = "fs")]
-    pub async fn compute_merkle_proof(
-        &self,
-        certificate: &CertificateMessage,
-        last_immutable_file_number_from_beacon: ImmutableFileNumber,
-        immutable_file_range: &ImmutableFileRange,
-        database_dir: &Path,
-        verified_digests: &VerifiedDigests,
-    ) -> MithrilResult<MKProof> {
-        self.artifact_prover
-            .compute_merkle_proof(
-                certificate,
-                last_immutable_file_number_from_beacon,
-                immutable_file_range,
-                database_dir,
-                verified_digests,
-            )
-            .await
-    }
-
     /// Checks if immutable directory exists with at least one immutable in it
     #[cfg(feature = "fs")]
     pub fn check_has_immutables(&self, database_dir: &Path) -> MithrilResult<()> {

mithril-client/src/cardano_database_client/proving.rs

@@ -7,16 +7,10 @@ use std::{
 
 use anyhow::{Context, anyhow};
 
-use mithril_cardano_node_internal_database::{
-    digesters::{CardanoImmutableDigester, ImmutableDigester},
-    entities::ImmutableFile,
-};
+use mithril_cardano_node_internal_database::entities::ImmutableFile;
 use mithril_common::{
-    crypto_helper::{MKProof, MKTree, MKTreeNode, MKTreeStoreInMemory},
-    entities::{
-        DigestLocation, HexEncodedDigest, ImmutableFileName, ImmutableFileNumber,
-        ProtocolMessagePartKey,
-    },
+    crypto_helper::{MKTree, MKTreeNode, MKTreeStoreInMemory},
+    entities::{DigestLocation, HexEncodedDigest, ImmutableFileName, ProtocolMessagePartKey},
     messages::{
         CardanoDatabaseDigestListItemMessage, CardanoDatabaseSnapshotMessage, CertificateMessage,
         DigestsMessagePart,
@@ -30,8 +24,6 @@ use crate::{
     utils::{create_directory_if_not_exists, delete_directory, read_files_in_directory},
 };
 
-use super::immutable_file_range::ImmutableFileRange;
-
 /// Represents the verified digests and the Merkle tree built from them.
 pub struct VerifiedDigests {
     /// A map of immutable file names to their corresponding verified digests.
@@ -54,31 +46,6 @@ impl InternalArtifactProver {
         }
     }
 
-    /// Compute the Merkle proof of membership for the given immutable file range.
-    pub async fn compute_merkle_proof(
-        &self,
-        certificate: &CertificateMessage,
-        last_immutable_file_number_from_beacon: ImmutableFileNumber,
-        immutable_file_range: &ImmutableFileRange,
-        database_dir: &Path,
-        verified_digests: &VerifiedDigests,
-    ) -> MithrilResult<MKProof> {
-        let network = certificate.metadata.network.clone();
-        let immutable_file_number_range =
-            immutable_file_range.to_range_inclusive(last_immutable_file_number_from_beacon)?;
-        let immutable_digester = CardanoImmutableDigester::new(network, None, self.logger.clone());
-        let computed_digests = immutable_digester
-            .compute_digests_for_range(database_dir, &immutable_file_number_range)
-            .await?
-            .entries
-            .values()
-            .map(MKTreeNode::from)
-            .collect::<Vec<_>>();
-
-        verified_digests.merkle_tree.compute_proof(&computed_digests)
-        // merkle_tree.compute_proof(&computed_digests)
-    }
-
     fn check_merkle_root_is_signed_by_certificate(
         certificate: &CertificateMessage,
         merkle_root: &MKTreeNode,
@@ -231,7 +198,6 @@ mod tests {
     use std::path::Path;
     use std::sync::Arc;
 
-    use mithril_cardano_node_internal_database::test::DummyCardanoDbBuilder;
     use mithril_common::{
         entities::{CardanoDbBeacon, Epoch, HexEncodedDigest},
         messages::CardanoDatabaseDigestListItemMessage,
@@ -245,61 +211,15 @@ mod tests {
 
     use super::*;
 
-    mod compute_merkle_proof {
-
-        use std::ops::RangeInclusive;
-
+    mod download_and_verify_digests {
         use mithril_common::{
             StdResult,
-            entities::{ImmutableFileNumber, ProtocolMessage, ProtocolMessagePartKey},
+            entities::{ProtocolMessage, ProtocolMessagePartKey},
             messages::DigestsMessagePart,
         };
 
         use super::*;
 
-        async fn prepare_db_and_verified_digests(
-            dir_name: &str,
-            beacon: &CardanoDbBeacon,
-            immutable_file_range: &RangeInclusive<ImmutableFileNumber>,
-        ) -> (PathBuf, CertificateMessage, VerifiedDigests) {
-            let certificate = CertificateMessage {
-                hash: "cert-hash-123".to_string(),
-                ..CertificateMessage::dummy()
-            };
-            let cardano_db = DummyCardanoDbBuilder::new(dir_name)
-                .with_immutables(&immutable_file_range.clone().collect::<Vec<_>>())
-                .append_immutable_trio()
-                .build();
-            let database_dir = cardano_db.get_dir();
-            let immutable_digester = CardanoImmutableDigester::new(
-                certificate.metadata.network.to_string(),
-                None,
-                TestLogger::stdout(),
-            );
-            let computed_digests = immutable_digester
-                .compute_digests_for_range(database_dir, immutable_file_range)
-                .await
-                .unwrap();
-
-            let digests = computed_digests
-                .entries
-                .iter()
-                .map(|(immutable_file, digest)| (immutable_file.filename.clone(), digest.clone()))
-                .collect::<BTreeMap<_, _>>();
-
-            let merkle_tree = immutable_digester
-                .compute_merkle_tree(database_dir, beacon)
-                .await
-                .unwrap();
-
-            let verified_digests = VerifiedDigests {
-                digests,
-                merkle_tree,
-            };
-
-            (database_dir.to_owned(), certificate, verified_digests)
-        }
-
         fn write_digest_file(
             digest_dir: &Path,
             digests: &BTreeMap<ImmutableFile, HexEncodedDigest>,
@@ -415,42 +335,6 @@ mod tests {
 
             assert!(!InternalArtifactProver::digest_target_dir().exists());
         }
-
-        #[tokio::test]
-        async fn compute_merkle_proof_succeeds() {
-            let beacon = CardanoDbBeacon {
-                epoch: Epoch(123),
-                immutable_file_number: 10,
-            };
-            let immutable_file_range = 1..=15;
-            let immutable_file_range_to_prove = ImmutableFileRange::Range(2, 4);
-            let (database_dir, certificate, verified_digests) = prepare_db_and_verified_digests(
-                "compute_merkle_proof_succeeds",
-                &beacon,
-                &immutable_file_range,
-            )
-            .await;
-            let expected_merkle_root = verified_digests.merkle_tree.compute_root().unwrap();
-
-            let client =
-                CardanoDatabaseClientDependencyInjector::new().build_cardano_database_client();
-
-            let merkle_proof = client
-                .compute_merkle_proof(
-                    &certificate,
-                    beacon.immutable_file_number,
-                    &immutable_file_range_to_prove,
-                    &database_dir,
-                    &verified_digests,
-                )
-                .await
-                .unwrap();
-
-            merkle_proof.verify().unwrap();
-
-            let merkle_proof_root = merkle_proof.root().to_owned();
-            assert_eq!(expected_merkle_root, merkle_proof_root);
-        }
     }
 
     mod download_unpack_digest_file {

mithril-client/tests/cardano_db_snapshot_list_get_download_verify.rs

@@ -139,19 +139,6 @@ async fn cardano_db_snapshot_list_get_download_verify() {
         .await
         .unwrap();
 
-    // let merkle_proof = client
-    //     .cardano_database_v2()
-    //     .compute_merkle_proof(
-    //         &certificate,
-    //         cardano_db_snapshot.beacon.immutable_file_number,
-    //         &immutable_file_range,
-    //         &unpacked_dir,
-    //         &verified_digests,
-    //     )
-    //     .await
-    //     .expect("Computing merkle proof should not fail");
-    // merkle_proof.verify().expect("Merkle proof should be valid"); //TODO verify?
-
     let message = MessageBuilder::new()
         .compute_cardano_database_message(
             &certificate,