Simplify certificate verifier usage

mithril-aggregator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.4.3"
+version = "0.4.4"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/src/dependency_injection/builder.rs

@@ -621,7 +621,10 @@ impl DependenciesBuilder {
     }
 
     async fn build_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
-        let verifier = Arc::new(MithrilCertificateVerifier::new(self.get_logger().await?));
+        let verifier = Arc::new(MithrilCertificateVerifier::new(
+            self.get_logger().await?,
+            self.get_certificate_repository().await?,
+        ));
 
         Ok(verifier)
     }

mithril-aggregator/src/services/certifier.rs

@@ -383,11 +383,7 @@ impl CertifierService for MithrilCertifierService {
         );
 
         self.certificate_verifier
-            .verify_certificate(
-                &certificate,
-                self.certificate_repository.clone(),
-                &self.genesis_verifier,
-            )
+            .verify_certificate(&certificate, &self.genesis_verifier.to_verification_key())
             .await
             .with_context(|| {
                 format!(
@@ -444,8 +440,7 @@ impl CertifierService for MithrilCertifierService {
             self.certificate_verifier
                 .verify_certificate_chain(
                     certificate.to_owned(),
-                    self.certificate_repository.clone(),
-                    &self.genesis_verifier,
+                    &self.genesis_verifier.to_verification_key(),
                 )
                 .await
                 .with_context(|| "CertificateVerifier can not verify certificate chain")?;
@@ -692,8 +687,7 @@ mod tests {
             .certificate_verifier
             .verify_certificate(
                 &certificate_created,
-                certifier_service.certificate_repository.clone(),
-                &certifier_service.genesis_verifier,
+                &certifier_service.genesis_verifier.to_verification_key(),
             )
             .await
             .unwrap();

mithril-aggregator/src/tools/genesis.rs

@@ -182,7 +182,10 @@ impl GenesisTools {
             genesis_signature,
         )?;
         self.certificate_verifier
-            .verify_genesis_certificate(&genesis_certificate, &self.genesis_verifier)
+            .verify_genesis_certificate(
+                &genesis_certificate,
+                &self.genesis_verifier.to_verification_key(),
+            )
             .await?;
         self.certificate_repository
             .create_certificate(genesis_certificate.clone())
@@ -243,7 +246,10 @@ mod tests {
         let connection = Connection::open_with_full_mutex(":memory:").unwrap();
         apply_all_migrations_to_db(&connection).unwrap();
         let certificate_store = Arc::new(CertificateRepository::new(Arc::new(connection)));
-        let certificate_verifier = Arc::new(MithrilCertificateVerifier::new(slog_scope::logger()));
+        let certificate_verifier = Arc::new(MithrilCertificateVerifier::new(
+            slog_scope::logger(),
+            certificate_store.clone(),
+        ));
         let genesis_avk = create_fake_genesis_avk();
         let genesis_verifier = Arc::new(genesis_signer.create_genesis_verifier());
         let genesis_tools = GenesisTools::new(
@@ -295,7 +301,10 @@ mod tests {
 
         assert_eq!(1, last_certificates.len());
         certificate_verifier
-            .verify_genesis_certificate(&last_certificates[0], &genesis_verifier)
+            .verify_genesis_certificate(
+                &last_certificates[0],
+                &genesis_verifier.to_verification_key(),
+            )
             .await
             .expect(
                 "verify_genesis_certificate should successfully validate the genesis certificate",
@@ -317,7 +326,10 @@ mod tests {
 
         assert_eq!(1, last_certificates.len());
         certificate_verifier
-            .verify_genesis_certificate(&last_certificates[0], &genesis_verifier)
+            .verify_genesis_certificate(
+                &last_certificates[0],
+                &genesis_verifier.to_verification_key(),
+            )
             .await
             .expect(
                 "verify_genesis_certificate should successfully validate the genesis certificate",

mithril-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-client"
-version = "0.4.13"
+version = "0.4.14"
 description = "A Mithril Client"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-client/src/dependencies/builder.rs

@@ -222,7 +222,10 @@ impl DependenciesBuilder {
     }
 
     async fn build_certificate_verifier(&mut self) -> StdResult<Arc<dyn CertificateVerifier>> {
-        let verifier = MithrilCertificateVerifier::new(self.get_logger().await?);
+        let verifier = MithrilCertificateVerifier::new(
+            self.get_logger().await?,
+            self.get_certificate_client().await?,
+        );
 
         Ok(Arc::new(verifier))
     }

mithril-client/src/services/mithril_stake_distribution.rs

@@ -36,9 +36,7 @@ use thiserror::Error;
 
 use mithril_common::{
     certificate_chain::CertificateVerifier,
-    crypto_helper::{
-        ProtocolAggregateVerificationKey, ProtocolGenesisVerificationKey, ProtocolGenesisVerifier,
-    },
+    crypto_helper::{ProtocolAggregateVerificationKey, ProtocolGenesisVerificationKey},
     entities::{MithrilStakeDistribution, ProtocolMessagePartKey},
     messages::MithrilStakeDistributionListItemMessage,
     protocol::SignerBuilder,
@@ -185,11 +183,7 @@ impl MithrilStakeDistributionService for AppMithrilStakeDistributionService {
                 })
                 .map_err(MithrilStakeDistributionServiceError::InvalidParameters)?;
         self.certificate_verifier
-            .verify_certificate_chain(
-                certificate.clone(),
-                self.certificate_client.clone(),
-                &ProtocolGenesisVerifier::from_verification_key(genesis_verification_key),
-            )
+            .verify_certificate_chain(certificate.clone(), &genesis_verification_key)
             .await?;
 
         let avk = self
@@ -289,10 +283,10 @@ mod tests {
     }
 
     /// Instantiate a Genesis Signer and its associated Verifier
-    pub fn setup_genesis() -> (ProtocolGenesisSigner, ProtocolGenesisVerifier) {
+    pub fn setup_genesis() -> (ProtocolGenesisSigner, ProtocolGenesisVerificationKey) {
         let genesis_signer = ProtocolGenesisSigner::create_deterministic_genesis_signer();
         let genesis_verifier = genesis_signer.create_genesis_verifier();
-        (genesis_signer, genesis_verifier)
+        (genesis_signer, genesis_verifier.to_verification_key())
     }
 
     #[tokio::test]
@@ -302,10 +296,14 @@ mod tests {
             Ok(serde_json::to_string(&get_stake_distribution_list_message()).unwrap())
         });
         let http_client = Arc::new(http_client);
+        let certificate_client = Arc::new(CertificateClient::new(http_client.clone()));
         let service = AppMithrilStakeDistributionService::new(
             Arc::new(MithrilStakeDistributionClient::new(http_client.clone())),
-            Arc::new(CertificateClient::new(http_client.clone())),
-            Arc::new(MithrilCertificateVerifier::new(slog_scope::logger())),
+            certificate_client.clone(),
+            Arc::new(MithrilCertificateVerifier::new(
+                slog_scope::logger(),
+                certificate_client,
+            )),
         );
         let list = service.list().await.unwrap();
 
@@ -338,7 +336,7 @@ mod tests {
         let mut certificate_verifier = MockCertificateVerifierImpl::new();
         certificate_verifier
             .expect_verify_certificate_chain()
-            .returning(|_, _, _| Ok(()))
+            .returning(|_, _| Ok(()))
             .times(1);
         certificate_verifier
             .expect_verify_protocol_message()
@@ -351,8 +349,7 @@ mod tests {
         );
 
         let dirpath = std::env::temp_dir().join("test_download_ok");
-        let (_, genesis_verifier) = setup_genesis();
-        let genesis_verification_key = genesis_verifier.to_verification_key();
+        let (_, genesis_verification_key) = setup_genesis();
         let filepath = service
             .download(
                 "hash-123",
@@ -391,7 +388,7 @@ mod tests {
         let mut certificate_verifier = MockCertificateVerifierImpl::new();
         certificate_verifier
             .expect_verify_certificate_chain()
-            .returning(|_, _, _| Ok(()))
+            .returning(|_, _| Ok(()))
             .times(1);
         certificate_verifier
             .expect_verify_protocol_message()
@@ -404,8 +401,7 @@ mod tests {
         );
 
         let dirpath = std::env::temp_dir().join("test_download_ko");
-        let (_, genesis_verifier) = setup_genesis();
-        let genesis_verification_key = genesis_verifier.to_verification_key();
+        let (_, genesis_verification_key) = setup_genesis();
         let _error = service
             .download(
                 "hash-123",
@@ -418,12 +414,15 @@ mod tests {
 
     #[tokio::test]
     async fn expand_eventual_artifact_hash_alias_should_returns_hash() {
-        let http_client = MockAggregatorHTTPClient::new();
-        let http_client = Arc::new(http_client);
+        let http_client = Arc::new(MockAggregatorHTTPClient::new());
+        let certificate_client = Arc::new(CertificateClient::new(http_client.clone()));
         let service = AppMithrilStakeDistributionService::new(
             Arc::new(MithrilStakeDistributionClient::new(http_client.clone())),
-            Arc::new(CertificateClient::new(http_client.clone())),
-            Arc::new(MithrilCertificateVerifier::new(slog_scope::logger())),
+            certificate_client.clone(),
+            Arc::new(MithrilCertificateVerifier::new(
+                slog_scope::logger(),
+                certificate_client,
+            )),
         );
 
         let hash = service
@@ -441,10 +440,14 @@ mod tests {
             Ok(serde_json::to_string(&get_stake_distribution_list_message()).unwrap())
         });
         let http_client = Arc::new(http_client);
+        let certificate_client = Arc::new(CertificateClient::new(http_client.clone()));
         let service = AppMithrilStakeDistributionService::new(
             Arc::new(MithrilStakeDistributionClient::new(http_client.clone())),
-            Arc::new(CertificateClient::new(http_client.clone())),
-            Arc::new(MithrilCertificateVerifier::new(slog_scope::logger())),
+            certificate_client.clone(),
+            Arc::new(MithrilCertificateVerifier::new(
+                slog_scope::logger(),
+                certificate_client,
+            )),
         );
 
         let hash = service
@@ -462,10 +465,14 @@ mod tests {
             Ok(serde_json::to_string(&get_stake_distribution_list_message()).unwrap())
         });
         let http_client = Arc::new(http_client);
+        let certificate_client = Arc::new(CertificateClient::new(http_client.clone()));
         let service = AppMithrilStakeDistributionService::new(
             Arc::new(MithrilStakeDistributionClient::new(http_client.clone())),
-            Arc::new(CertificateClient::new(http_client.clone())),
-            Arc::new(MithrilCertificateVerifier::new(slog_scope::logger())),
+            certificate_client.clone(),
+            Arc::new(MithrilCertificateVerifier::new(
+                slog_scope::logger(),
+                certificate_client,
+            )),
         );
 
         let hash = service
@@ -483,10 +490,14 @@ mod tests {
             .expect_get_content()
             .returning(|_| Ok("[]".to_string()));
         let http_client = Arc::new(http_client);
+        let certificate_client = Arc::new(CertificateClient::new(http_client.clone()));
         let service = AppMithrilStakeDistributionService::new(
             Arc::new(MithrilStakeDistributionClient::new(http_client.clone())),
-            Arc::new(CertificateClient::new(http_client.clone())),
-            Arc::new(MithrilCertificateVerifier::new(slog_scope::logger())),
+            certificate_client.clone(),
+            Arc::new(MithrilCertificateVerifier::new(
+                slog_scope::logger(),
+                certificate_client,
+            )),
         );
 
         let err = service

mithril-client/src/services/mock.rs

@@ -1,9 +1,8 @@
 use std::path::Path;
-use std::sync::Arc;
 
 use async_trait::async_trait;
-use mithril_common::certificate_chain::{CertificateRetriever, CertificateVerifier};
-use mithril_common::crypto_helper::ProtocolGenesisVerifier;
+use mithril_common::certificate_chain::CertificateVerifier;
+use mithril_common::crypto_helper::ProtocolGenesisVerificationKey;
 use mithril_common::digesters::{ImmutableDigester, ImmutableDigesterError};
 use mithril_common::entities::{Beacon, Certificate, ProtocolMessage};
 use mithril_common::StdResult;
@@ -30,21 +29,19 @@ mock! {
         async fn verify_genesis_certificate(
             &self,
             genesis_certificate: &Certificate,
-            genesis_verifier: &ProtocolGenesisVerifier,
+            genesis_verification_key: &ProtocolGenesisVerificationKey,
         ) -> StdResult<()>;
 
         async fn verify_certificate(
             &self,
             certificate: &Certificate,
-            certificate_retriever: Arc<dyn CertificateRetriever>,
-            genesis_verifier: &ProtocolGenesisVerifier,
+            genesis_verification_key: &ProtocolGenesisVerificationKey,
         ) -> StdResult<Option<Certificate>>;
 
         async fn verify_certificate_chain(
             &self,
             certificate: Certificate,
-            certificate_retriever: Arc<dyn CertificateRetriever>,
-            genesis_verifier: &ProtocolGenesisVerifier,
+            genesis_verification_key: &ProtocolGenesisVerificationKey,
         ) -> StdResult<()>;
 
         fn verify_protocol_message(

mithril-client/src/services/snapshot.rs

@@ -161,11 +161,7 @@ impl MithrilClientSnapshotService {
             ProtocolGenesisVerifier::from_verification_key(genesis_verification_key);
 
         self.certificate_verifier
-            .verify_certificate_chain(
-                certificate.clone(),
-                self.certificate_client.clone(),
-                &genesis_verifier,
-            )
+            .verify_certificate_chain(certificate.clone(), &genesis_verifier.to_verification_key())
             .await?;
 
         Ok(())
@@ -458,7 +454,7 @@ mod tests {
         let mut certificate_verifier = MockCertificateVerifierImpl::new();
         certificate_verifier
             .expect_verify_certificate_chain()
-            .returning(|_, _, _| Ok(()))
+            .returning(|_, _| Ok(()))
             .times(1);
 
         let dumb_digester = DumbImmutableDigester::new("snapshot-digest-123", true);

mithril-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.2.129"
+version = "0.2.130"
 authors = { workspace = true }
 edition = { workspace = true }
 documentation = { workspace = true }