Merge pull request #886 from input-output-hk/greg/852/immutable_signable

immutable signable service

Author: ghubertpalo

Cargo.lock

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

mithril-aggregator/Cargo.toml

@@ -42,7 +42,9 @@ use crate::{
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
-    signable_builder::{MithrilStakeDistributionSignableBuilder, SignableBuilderService},
+    signable_builder::{
+        ImmutableSignableBuilder, MithrilStakeDistributionSignableBuilder, SignableBuilderService,
+    },
     signer_registerer::SignerRecorder,
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     ticker_service::{MithrilTickerService, TickerService},
@@ -875,8 +877,11 @@ impl DependenciesBuilder {
         let multi_signer = self.get_multi_signer().await?;
         let mithril_stake_distribution_builder =
             MithrilStakeDistributionSignableBuilder::new(multi_signer);
+        let immutable_signable_builder =
+            ImmutableSignableBuilder::new(self.get_immutable_digester().await?);
         let signable_builder_service = Arc::new(SignableBuilderService::new(
             mithril_stake_distribution_builder,
+            immutable_signable_builder,
         ));
 
         Ok(signable_builder_service)

mithril-aggregator/src/dependency_injection/builder.rs

@@ -0,0 +1,66 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use mithril_common::{
+    digesters::ImmutableDigester,
+    entities::{Beacon, ProtocolMessage, ProtocolMessagePartKey},
+    signable_builder::SignableBuilder,
+    StdResult,
+};
+
+pub struct ImmutableSignableBuilder {
+    immutable_digester: Arc<dyn ImmutableDigester>,
+}
+
+impl ImmutableSignableBuilder {
+    /// Constructor
+    pub fn new(immutable_digester: Arc<dyn ImmutableDigester>) -> Self {
+        Self { immutable_digester }
+    }
+}
+
+#[async_trait]
+impl SignableBuilder<Beacon, ProtocolMessage> for ImmutableSignableBuilder {
+    async fn compute_signable(&self, beacon: Beacon) -> StdResult<ProtocolMessage> {
+        let digest = self.immutable_digester.compute_digest(&beacon).await?;
+        let mut protocol_message = ProtocolMessage::new();
+        protocol_message.set_message_part(ProtocolMessagePartKey::SnapshotDigest, digest);
+
+        Ok(protocol_message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use async_trait::async_trait;
+    use mithril_common::digesters::{ImmutableDigester, ImmutableDigesterError};
+    use mithril_common::entities::Beacon;
+
+    #[derive(Default)]
+    pub struct ImmutableDigesterImpl;
+
+    #[async_trait]
+    impl ImmutableDigester for ImmutableDigesterImpl {
+        async fn compute_digest(&self, beacon: &Beacon) -> Result<String, ImmutableDigesterError> {
+            Ok(format!("immutable {}", beacon.immutable_file_number))
+        }
+    }
+    #[tokio::test]
+    async fn compute_signable() {
+        let digester = ImmutableDigesterImpl::default();
+        let signable_builder = ImmutableSignableBuilder::new(Arc::new(digester));
+        let protocol_message = signable_builder
+            .compute_signable(Beacon::default())
+            .await
+            .unwrap();
+
+        assert_eq!(
+            &"immutable 0".to_string(),
+            protocol_message
+                .get_message_part(&ProtocolMessagePartKey::SnapshotDigest)
+                .unwrap()
+        );
+    }
+}

mithril-aggregator/src/signable_builder/immutable_signable_builder.rs

@@ -1,7 +1,9 @@
 //! The module used for building signables
 
+mod immutable_signable_builder;
 mod mithril_stake_distribution;
 mod signable_builder_service;
 
+pub use immutable_signable_builder::*;
 pub use mithril_stake_distribution::*;
 pub use signable_builder_service::*;

mithril-aggregator/src/signable_builder/mod.rs

@@ -6,20 +6,23 @@ use mithril_common::{
     StdResult,
 };
 
-use super::MithrilStakeDistributionSignableBuilder;
+use super::{ImmutableSignableBuilder, MithrilStakeDistributionSignableBuilder};
 
 /// SignableBuilder Service
 pub struct SignableBuilderService {
     mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
+    immutable_signable_builder: ImmutableSignableBuilder,
 }
 
 impl SignableBuilderService {
     /// SignableBuilderService factory
     pub fn new(
         mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
+        immutable_signable_builder: ImmutableSignableBuilder,
     ) -> Self {
         Self {
             mithril_stake_distribution_builder,
+            immutable_signable_builder,
         }
     }
 }
@@ -36,6 +39,11 @@ impl SignableBuilderService {
                     .compute_signable(e)
                     .await?,
             ),
+            SignedEntityType::CardanoImmutableFilesFull(beacon) => Arc::new(
+                self.immutable_signable_builder
+                    .compute_signable(beacon)
+                    .await?,
+            ),
             _ => todo!(),
         };
 

mithril-aggregator/src/signable_builder/signable_builder_service.rs

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

mithril-common/Cargo.toml

@@ -1,4 +1,5 @@
 use crate::entities::{Epoch, ImmutableFileNumber};
+use crate::signable_builder::Beacon as Beaconable;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use std::cmp::Ordering;
@@ -18,6 +19,8 @@ pub struct Beacon {
     pub immutable_file_number: ImmutableFileNumber,
 }
 
+impl Beaconable for Beacon {}
+
 /// A BeaconComparison is the result of the comparison between a beacon and an oldest beacon.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum BeaconComparison {