Simplify Mithril Stake Distribution signable builder

Author: jpraynaud

mithril-aggregator/src/dependency_injection/builder.rs

@@ -876,9 +876,7 @@ impl DependenciesBuilder {
     }
 
     async fn build_signable_builder_service(&mut self) -> Result<Arc<SignableBuilderService>> {
-        let multi_signer = self.get_multi_signer().await?;
-        let mithril_stake_distribution_builder =
-            MithrilStakeDistributionSignableBuilder::new(multi_signer);
+        let mithril_stake_distribution_builder = MithrilStakeDistributionSignableBuilder::new();
         let immutable_signable_builder = CardanoImmutableFilesFullSignableBuilder::new(
             self.get_immutable_digester().await?,
             self.get_logger().await?,

mithril-aggregator/src/signable_builder/mithril_stake_distribution.rs

@@ -1,68 +1,48 @@
-use std::sync::Arc;
-
 use async_trait::async_trait;
-use tokio::sync::RwLock;
 
 use mithril_common::{
-    entities::{Epoch, ProtocolMessage, ProtocolMessagePartKey},
+    entities::{Epoch, ProtocolMessage},
     signable_builder::SignableBuilder,
     StdResult,
 };
 
-use crate::MultiSigner;
-
-/// A [SignableBuilder] for mithril stake distribution.
-pub struct MithrilStakeDistributionSignableBuilder {
-    multi_signer: Arc<RwLock<dyn MultiSigner>>,
-}
+/// A [MithrilStakeDistributionSignable] builder
+pub struct MithrilStakeDistributionSignableBuilder {}
 
 impl MithrilStakeDistributionSignableBuilder {
     /// MithrilStakeDistribution signable builder factory
-    pub fn new(multi_signer: Arc<RwLock<dyn MultiSigner>>) -> Self {
-        Self { multi_signer }
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for MithrilStakeDistributionSignableBuilder {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
 #[async_trait]
 impl SignableBuilder<Epoch, ProtocolMessage> 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> {
-        let mut protocol_message = ProtocolMessage::new();
-        let multi_signer = self.multi_signer.read().await;
-        protocol_message.set_message_part(
-            ProtocolMessagePartKey::NextAggregateVerificationKey,
-            multi_signer
-                .compute_next_stake_distribution_aggregate_verification_key()
-                .await?
-                .unwrap_or_default(),
-        );
-
-        Ok(protocol_message)
+        Ok(ProtocolMessage::new())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use crate::multi_signer::MockMultiSigner;
-
     #[tokio::test]
     async fn test_compute_signable() {
-        let mut mock_multi_signer = MockMultiSigner::new();
-        mock_multi_signer
-            .expect_compute_next_stake_distribution_aggregate_verification_key()
-            .return_once(|| Ok(Some("avk-123".to_string())));
         let mithril_stake_distribution_signable_builder =
-            MithrilStakeDistributionSignableBuilder::new(Arc::new(RwLock::new(mock_multi_signer)));
+            MithrilStakeDistributionSignableBuilder::new();
         let signable = mithril_stake_distribution_signable_builder
             .compute_signable(Epoch(1))
             .await
             .unwrap();
-        let mut signable_expected = ProtocolMessage::new();
-        signable_expected.set_message_part(
-            ProtocolMessagePartKey::NextAggregateVerificationKey,
-            "avk-123".to_string(),
-        );
+        let signable_expected = ProtocolMessage::new();
         assert_eq!(signable_expected, signable);
     }
 }