refactor(signer): impl SignaturePublisher directly on AggregatorHttpClient

Instead of implementing the publisher on the signer `AggregatorClient`,
removing an intermediate layer

Author: Alenar

mithril-signer/src/runtime/runner.rs

@@ -415,8 +415,8 @@ mod tests {
     use crate::metrics::MetricsService;
     use crate::services::{
         CardanoTransactionsImporter, DumbAggregatorClient, MithrilEpochService,
-        MithrilSingleSigner, MockTransactionStore, MockUpkeepService, SignerCertifierService,
-        SignerSignableSeedBuilder, SignerSignedEntityConfigProvider,
+        MithrilSingleSigner, MockTransactionStore, MockUpkeepService, SignaturePublisherNoop,
+        SignerCertifierService, SignerSignableSeedBuilder, SignerSignedEntityConfigProvider,
     };
     use crate::test_tools::TestLogger;
 
@@ -552,7 +552,7 @@ mod tests {
             Arc::new(SignerSignedEntityConfigProvider::new(epoch_service.clone())),
             signed_entity_type_lock.clone(),
             single_signer.clone(),
-            aggregator_client.clone(),
+            Arc::new(SignaturePublisherNoop),
             logger.clone(),
         ));
         let kes_signer = None;

mithril-signer/src/services/aggregator_client.rs

@@ -1,21 +1,17 @@
-use anyhow::anyhow;
 use async_trait::async_trait;
 
+use mithril_aggregator_client::AggregatorHttpClient;
 use mithril_aggregator_client::query::{
-    GetAggregatorFeaturesQuery, GetEpochSettingsQuery, PostRegisterSignatureQuery,
-    PostRegisterSignerQuery,
+    GetAggregatorFeaturesQuery, GetEpochSettingsQuery, PostRegisterSignerQuery,
 };
-use mithril_aggregator_client::{AggregatorHttpClient, AggregatorHttpClientError};
 use mithril_common::{
     StdResult,
-    entities::{Epoch, ProtocolMessage, SignedEntityType, Signer, SingleSignature},
+    entities::{Epoch, Signer},
     messages::{AggregatorFeaturesMessage, TryFromMessageAdapter, TryToMessageAdapter},
 };
 
 use crate::entities::SignerEpochSettings;
-use crate::message_adapters::{
-    FromEpochSettingsAdapter, ToRegisterSignatureMessageAdapter, ToRegisterSignerMessageAdapter,
-};
+use crate::message_adapters::{FromEpochSettingsAdapter, ToRegisterSignerMessageAdapter};
 
 /// Trait for mocking and testing a `AggregatorClient`
 #[cfg_attr(test, mockall::automock)]
@@ -27,14 +23,6 @@ pub trait AggregatorClient: Sync + Send {
     /// Registers signer with the aggregator.
     async fn register_signer(&self, epoch: Epoch, signer: &Signer) -> StdResult<()>;
 
-    /// Registers single signature with the aggregator.
-    async fn register_signature(
-        &self,
-        signed_entity_type: &SignedEntityType,
-        signature: &SingleSignature,
-        protocol_message: &ProtocolMessage,
-    ) -> StdResult<()>;
-
     /// Retrieves aggregator features message from the aggregator
     async fn retrieve_aggregator_features(&self) -> StdResult<AggregatorFeaturesMessage>;
 }
@@ -58,27 +46,6 @@ impl AggregatorClient for AggregatorHttpClient {
         Ok(())
     }
 
-    async fn register_signature(
-        &self,
-        signed_entity_type: &SignedEntityType,
-        signature: &SingleSignature,
-        protocol_message: &ProtocolMessage,
-    ) -> StdResult<()> {
-        let register_single_signature_message = ToRegisterSignatureMessageAdapter::try_adapt((
-            signed_entity_type.to_owned(),
-            signature.to_owned(),
-            protocol_message,
-        ))
-        .map_err(|e| AggregatorHttpClientError::JsonParseFailed(anyhow!(e)))?;
-
-        self.send(PostRegisterSignatureQuery::new(
-            register_single_signature_message,
-        ))
-        .await?;
-
-        Ok(())
-    }
-
     async fn retrieve_aggregator_features(&self) -> StdResult<AggregatorFeaturesMessage> {
         let aggregator_features = self.send(GetAggregatorFeaturesQuery::current()).await?;
         Ok(aggregator_features)
@@ -145,16 +112,6 @@ pub(crate) mod dumb {
             Ok(())
         }
 
-        /// Registers single signature with the aggregator
-        async fn register_signature(
-            &self,
-            _signed_entity_type: &SignedEntityType,
-            _signature: &SingleSignature,
-            _protocol_message: &ProtocolMessage,
-        ) -> StdResult<()> {
-            Ok(())
-        }
-
         async fn retrieve_aggregator_features(&self) -> StdResult<AggregatorFeaturesMessage> {
             let aggregator_features = self.aggregator_features.read().await;
             Ok(aggregator_features.clone())

mithril-signer/src/services/signature_publisher/http.rs

@@ -1,21 +1,37 @@
+use anyhow::Context;
 use async_trait::async_trait;
-use mithril_common::StdResult;
-use mithril_common::entities::{ProtocolMessage, SignedEntityType, SingleSignature};
 
-use crate::services::AggregatorClient;
+use mithril_aggregator_client::{AggregatorHttpClient, query::PostRegisterSignatureQuery};
+use mithril_common::{
+    StdResult,
+    entities::{ProtocolMessage, SignedEntityType, SingleSignature},
+    messages::TryToMessageAdapter,
+};
+
+use crate::message_adapters::ToRegisterSignatureMessageAdapter;
 
 use super::SignaturePublisher;
 
 #[async_trait]
-impl<T: AggregatorClient> SignaturePublisher for T {
+impl SignaturePublisher for AggregatorHttpClient {
     async fn publish(
         &self,
         signed_entity_type: &SignedEntityType,
         signature: &SingleSignature,
         protocol_message: &ProtocolMessage,
     ) -> StdResult<()> {
-        self.register_signature(signed_entity_type, signature, protocol_message)
-            .await?;
+        let register_single_signature_message = ToRegisterSignatureMessageAdapter::try_adapt((
+            signed_entity_type.to_owned(),
+            signature.to_owned(),
+            protocol_message,
+        ))
+        .with_context(|| "Failed to adapt message to register single signature message")?;
+
+        self.send(PostRegisterSignatureQuery::new(
+            register_single_signature_message,
+        ))
+        .await?;
+
         Ok(())
     }
 }

mithril-signer/tests/test_extensions/certificate_handler.rs

@@ -14,6 +14,7 @@ use mithril_common::{
 };
 use mithril_ticker::{MithrilTickerService, TickerService};
 
+use mithril_signer::services::SignaturePublisher;
 use mithril_signer::{entities::SignerEpochSettings, services::AggregatorClient};
 
 pub struct FakeAggregator {
@@ -80,6 +81,18 @@ impl FakeAggregator {
     }
 }
 
+#[async_trait]
+impl SignaturePublisher for FakeAggregator {
+    async fn publish(
+        &self,
+        _signed_entity_type: &SignedEntityType,
+        _signature: &SingleSignature,
+        _protocol_message: &ProtocolMessage,
+    ) -> StdResult<()> {
+        Ok(())
+    }
+}
+
 #[async_trait]
 impl AggregatorClient for FakeAggregator {
     async fn retrieve_epoch_settings(&self) -> StdResult<Option<SignerEpochSettings>> {
@@ -109,16 +122,6 @@ impl AggregatorClient for FakeAggregator {
         Ok(())
     }
 
-    /// Registers single signatures with the aggregator
-    async fn register_signature(
-        &self,
-        _signed_entity_type: &SignedEntityType,
-        _signature: &SingleSignature,
-        _protocol_message: &ProtocolMessage,
-    ) -> StdResult<()> {
-        Ok(())
-    }
-
     async fn retrieve_aggregator_features(&self) -> StdResult<AggregatorFeaturesMessage> {
         let signed_entity_config = self.signed_entity_config.read().await;