Refactor remove Signable trait

Which is not needed anymore as Signable Builder returns a ProtocolMessage directly.

Author: jpraynaud

mithril-aggregator/src/artifact_builder/artifact_builder_service.rs

@@ -69,7 +69,7 @@ impl ArtifactBuilderService for MithrilArtifactBuilderService {
                     .compute_artifact(beacon, certificate)
                     .await?,
             )),
-            _ => todo!(),
+            SignedEntityType::CardanoStakeDistribution(_) => todo!(),
         }
     }
 }

mithril-aggregator/src/artifact_builder/dummy_artifact.rs

@@ -1,13 +1,15 @@
 use async_trait::async_trait;
 use mithril_common::{
-    entities::Certificate,
-    signable_builder::{Artifact, DummyBeacon},
+    entities::{Beacon, Certificate},
+    signable_builder::Artifact,
     StdResult,
 };
 use serde::{Deserialize, Serialize};
 
 use crate::artifact_builder::ArtifactBuilder;
 
+type DummyBeacon = Beacon;
+
 /// Dummy artifact
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 pub struct DummyArtifact {

mithril-aggregator/src/runtime/runner.rs

@@ -356,12 +356,11 @@ impl AggregatorRunnerTrait for AggregatorRunner {
         signed_entity_type: &SignedEntityType,
     ) -> Result<ProtocolMessage, Box<dyn StdError + Sync + Send>> {
         debug!("RUNNER: compute protocol message");
-        let signable = self
+        let mut protocol_message = self
             .dependencies
             .signable_builder_service
-            .compute_signable(signed_entity_type.to_owned())
+            .compute_protocol_message(signed_entity_type.to_owned())
             .await?;
-        let mut protocol_message = signable.compute_protocol_message()?;
 
         let multi_signer = self.dependencies.multi_signer.write().await;
         protocol_message.set_message_part(

mithril-aggregator/src/signable_builder/signable_builder_service.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::{Beacon, Epoch, ProtocolMessage, SignedEntityType},
-    signable_builder::{Signable, SignableBuilder},
+    signable_builder::SignableBuilder,
     StdResult,
 };
 
@@ -15,23 +15,23 @@ use mockall::automock;
 #[async_trait]
 pub trait SignableBuilderService: Send + Sync {
     /// Compute signable from signed entity type
-    async fn compute_signable(
+    async fn compute_protocol_message(
         &self,
         signed_entity_type: SignedEntityType,
-    ) -> StdResult<Arc<dyn Signable>>;
+    ) -> StdResult<ProtocolMessage>;
 }
 
 /// Mithril Signable Builder Service
 pub struct MithrilSignableBuilderService {
-    mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch, ProtocolMessage>>,
-    immutable_signable_builder: Arc<dyn SignableBuilder<Beacon, ProtocolMessage>>,
+    mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch>>,
+    immutable_signable_builder: Arc<dyn SignableBuilder<Beacon>>,
 }
 
 impl MithrilSignableBuilderService {
     /// MithrilSignableBuilderService factory
     pub fn new(
-        mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch, ProtocolMessage>>,
-        immutable_signable_builder: Arc<dyn SignableBuilder<Beacon, ProtocolMessage>>,
+        mithril_stake_distribution_builder: Arc<dyn SignableBuilder<Epoch>>,
+        immutable_signable_builder: Arc<dyn SignableBuilder<Beacon>>,
     ) -> Self {
         Self {
             mithril_stake_distribution_builder,
@@ -42,26 +42,25 @@ impl MithrilSignableBuilderService {
 
 #[async_trait]
 impl SignableBuilderService for MithrilSignableBuilderService {
-    #[allow(dead_code)]
-    async fn compute_signable(
+    async fn compute_protocol_message(
         &self,
         signed_entity_type: SignedEntityType,
-    ) -> StdResult<Arc<dyn Signable>> {
-        let signable: Arc<dyn Signable> = match signed_entity_type {
-            SignedEntityType::MithrilStakeDistribution(e) => Arc::new(
+    ) -> StdResult<ProtocolMessage> {
+        let protocol_message = match signed_entity_type {
+            SignedEntityType::MithrilStakeDistribution(e) => {
                 self.mithril_stake_distribution_builder
-                    .compute_signable(e)
-                    .await?,
-            ),
-            SignedEntityType::CardanoImmutableFilesFull(beacon) => Arc::new(
+                    .compute_protocol_message(e)
+                    .await?
+            }
+            SignedEntityType::CardanoImmutableFilesFull(beacon) => {
                 self.immutable_signable_builder
-                    .compute_signable(beacon)
-                    .await?,
-            ),
-            _ => todo!(),
+                    .compute_protocol_message(beacon)
+                    .await?
+            }
+            SignedEntityType::CardanoStakeDistribution(_) => todo!(),
         };
 
-        Ok(signable)
+        Ok(protocol_message)
     }
 }
 
@@ -71,22 +70,21 @@ mod tests {
 
     use mithril_common::{
         entities::{Epoch, ProtocolMessage},
-        signable_builder::{Beacon as Beaconnable, Signable, SignableBuilder},
+        signable_builder::{Beacon as Beaconnable, SignableBuilder},
         StdResult,
     };
 
     use async_trait::async_trait;
     use mockall::mock;
 
     mock! {
-        SignableBuilderImpl<U, V> { }
+        SignableBuilderImpl<U> { }
 
         #[async_trait]
-        impl<U, V> SignableBuilder<U, V> for SignableBuilderImpl<U, V> where
-        U: Beaconnable,
-        V: Signable,{
+        impl<U> SignableBuilder<U> for SignableBuilderImpl<U> where U: Beaconnable,
+        {
 
-            async fn compute_signable(&self, beacon: U) -> StdResult<V>;
+            async fn compute_protocol_message(&self, beacon: U) -> StdResult<ProtocolMessage>;
         }
     }
 
@@ -96,14 +94,14 @@ mod tests {
         let protocol_message = ProtocolMessage::new();
         let protocol_message_clone = protocol_message.clone();
         let mut mock_mithril_stake_distribution_signable_builder =
-            MockSignableBuilderImpl::<Epoch, ProtocolMessage>::new();
+            MockSignableBuilderImpl::<Epoch>::new();
         mock_mithril_stake_distribution_signable_builder
-            .expect_compute_signable()
+            .expect_compute_protocol_message()
             .once()
             .return_once(move |_| Ok(protocol_message_clone));
 
         let mock_cardano_immutable_files_full_signable_builder =
-            MockSignableBuilderImpl::<Beacon, ProtocolMessage>::new();
+            MockSignableBuilderImpl::<Beacon>::new();
 
         let signable_builder_service = MithrilSignableBuilderService::new(
             Arc::new(mock_mithril_stake_distribution_signable_builder),
@@ -112,7 +110,7 @@ mod tests {
 
         let signed_entity_type = SignedEntityType::MithrilStakeDistribution(Epoch(1));
         signable_builder_service
-            .compute_signable(signed_entity_type)
+            .compute_protocol_message(signed_entity_type)
             .await
             .unwrap();
     }
@@ -122,12 +120,12 @@ mod tests {
         let protocol_message = ProtocolMessage::new();
         let protocol_message_clone = protocol_message.clone();
         let mock_mithril_stake_distribution_signable_builder =
-            MockSignableBuilderImpl::<Epoch, ProtocolMessage>::new();
+            MockSignableBuilderImpl::<Epoch>::new();
 
         let mut mock_cardano_immutable_files_full_signable_builder =
-            MockSignableBuilderImpl::<Beacon, ProtocolMessage>::new();
+            MockSignableBuilderImpl::<Beacon>::new();
         mock_cardano_immutable_files_full_signable_builder
-            .expect_compute_signable()
+            .expect_compute_protocol_message()
             .once()
             .return_once(move |_| Ok(protocol_message_clone));
 
@@ -138,7 +136,7 @@ mod tests {
 
         let signed_entity_type = SignedEntityType::CardanoImmutableFilesFull(Beacon::default());
         signable_builder_service
-            .compute_signable(signed_entity_type)
+            .compute_protocol_message(signed_entity_type)
             .await
             .unwrap();
     }

mithril-common/src/entities/protocol_message.rs

@@ -2,8 +2,6 @@ use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use std::{collections::BTreeMap, fmt::Display};
 
-use crate::{signable_builder::Signable, StdResult};
-
 /// The key of a ProtocolMessage
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ProtocolMessagePartKey {
@@ -75,12 +73,6 @@ impl ProtocolMessage {
     }
 }
 
-impl Signable for ProtocolMessage {
-    fn compute_protocol_message(&self) -> StdResult<ProtocolMessage> {
-        Ok(self.clone())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

mithril-common/src/signable_builder/cardano_immutable_full_signable_builder.rs

@@ -26,8 +26,8 @@ impl CardanoImmutableFilesFullSignableBuilder {
 }
 
 #[async_trait]
-impl SignableBuilder<Beacon, ProtocolMessage> for CardanoImmutableFilesFullSignableBuilder {
-    async fn compute_signable(&self, beacon: Beacon) -> StdResult<ProtocolMessage> {
+impl SignableBuilder<Beacon> for CardanoImmutableFilesFullSignableBuilder {
+    async fn compute_protocol_message(&self, beacon: Beacon) -> StdResult<ProtocolMessage> {
         debug!(self.logger, "SignableBuilder::compute_signable({beacon:?})");
         let digest = self.immutable_digester.compute_digest(&beacon).await?;
         info!(self.logger, "SignableBuilder: digest = '{digest}'.");
@@ -69,7 +69,7 @@ mod tests {
         let signable_builder =
             CardanoImmutableFilesFullSignableBuilder::new(Arc::new(digester), create_logger());
         let protocol_message = signable_builder
-            .compute_signable(Beacon::default())
+            .compute_protocol_message(Beacon::default())
             .await
             .unwrap();
 

mithril-common/src/signable_builder/dummy_signable.rs

@@ -9,24 +9,17 @@ use mockall::automock;
 /// Beacon trait
 pub trait Beacon: Send + Sync {}
 
-/// Signable is a trait for types that can be converted to a protocol message
-pub trait Signable: Send + Sync {
-    /// Compute protocol message
-    fn compute_protocol_message(&self) -> StdResult<ProtocolMessage>;
-}
-
 /// Artifact is a trait for types that represent signed artifacts
 #[typetag::serde(tag = "type")]
 pub trait Artifact: Debug + Send + Sync {}
 
-/// SignableBuilder is trait for building a signable for a beacon
+/// SignableBuilder is trait for building a protocol message for a beacon
 #[cfg_attr(test, automock)]
 #[async_trait]
-pub trait SignableBuilder<U, V>: Send + Sync
+pub trait SignableBuilder<U>: Send + Sync
 where
     U: Beacon,
-    V: Signable,
 {
-    /// Compute a signable
-    async fn compute_signable(&self, beacon: U) -> StdResult<V>;
+    /// Compute a protocol message
+    async fn compute_protocol_message(&self, beacon: U) -> StdResult<ProtocolMessage>;
 }

mithril-common/src/signable_builder/interface.rs

@@ -11,9 +11,9 @@ use crate::{
 pub struct MithrilStakeDistributionSignableBuilder {}
 
 #[async_trait]
-impl SignableBuilder<Epoch, ProtocolMessage> for MithrilStakeDistributionSignableBuilder {
+impl SignableBuilder<Epoch> for MithrilStakeDistributionSignableBuilder {
     // We just need to return an empty protocol message as the next AVK will be appended by the signing engine automatically
-    async fn compute_signable(&self, _beacon: Epoch) -> StdResult<ProtocolMessage> {
+    async fn compute_protocol_message(&self, _beacon: Epoch) -> StdResult<ProtocolMessage> {
         Ok(ProtocolMessage::new())
     }
 }
@@ -27,7 +27,7 @@ mod tests {
         let mithril_stake_distribution_signable_builder =
             MithrilStakeDistributionSignableBuilder::default();
         let signable = mithril_stake_distribution_signable_builder
-            .compute_signable(Epoch(1))
+            .compute_protocol_message(Epoch(1))
             .await
             .unwrap();
         let signable_expected = ProtocolMessage::new();

mithril-common/src/signable_builder/mithril_stake_distribution.rs

@@ -1,11 +1,9 @@
 //! The module used for building signables
 
 mod cardano_immutable_full_signable_builder;
-mod dummy_signable;
 mod interface;
 mod mithril_stake_distribution;
 
 pub use cardano_immutable_full_signable_builder::*;
-pub use dummy_signable::*;
 pub use interface::*;
 pub use mithril_stake_distribution::*;