Merge pull request #867 from input-output-hk/jpraynaud/851-signable-artifact-builder-mithril-stake-distribution

Mithril Stake Distribution Signable builder in aggregator

Author: jpraynaud

Cargo.lock

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

mithril-aggregator/Cargo.toml

@@ -16,7 +16,6 @@ use mithril_common::{
         adapters::{EraReaderAdapterBuilder, EraReaderDummyAdapter},
         EraChecker, EraMarker, EraReader, EraReaderAdapter, SupportedEra,
     },
-    signable_builder::DummySignableBuilder,
     store::adapter::{MemoryAdapter, SQLiteAdapter, StoreAdapter},
     BeaconProvider, BeaconProviderImpl,
 };
@@ -43,7 +42,7 @@ use crate::{
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
-    signable_builder::SignableBuilderService,
+    signable_builder::{MithrilStakeDistributionSignableBuilder, SignableBuilderService},
     signer_registerer::SignerRecorder,
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     ticker_service::{MithrilTickerService, TickerService},
@@ -873,9 +872,12 @@ impl DependenciesBuilder {
     }
 
     async fn build_signable_builder_service(&mut self) -> Result<Arc<SignableBuilderService>> {
-        let dummy_signable_builder = DummySignableBuilder::new();
-        let signable_builder_service =
-            Arc::new(SignableBuilderService::new(dummy_signable_builder));
+        let multi_signer = self.get_multi_signer().await?;
+        let mithril_stake_distribution_builder =
+            MithrilStakeDistributionSignableBuilder::new(multi_signer);
+        let signable_builder_service = Arc::new(SignableBuilderService::new(
+            mithril_stake_distribution_builder,
+        ));
 
         Ok(signable_builder_service)
     }

mithril-aggregator/src/dependency_injection/builder.rs

@@ -55,7 +55,6 @@ mod handlers {
                             protocol_parameters,
                             next_protocol_parameters,
                         };
-                        println!("EpochSettings={epoch_settings:?}");
                         let epoch_settings_message =
                             ToEpochSettingsMessageAdapter::adapt(epoch_settings);
                         Ok(reply::json(&epoch_settings_message, StatusCode::OK))

mithril-aggregator/src/http_server/routes/epoch_routes.rs

@@ -0,0 +1,68 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tokio::sync::RwLock;
+
+use mithril_common::{
+    entities::{Epoch, ProtocolMessage, ProtocolMessagePartKey},
+    signable_builder::SignableBuilder,
+    StdResult,
+};
+
+use crate::MultiSigner;
+
+/// A [MithrilStakeDistributionSignable] builder
+pub struct MithrilStakeDistributionSignableBuilder {
+    multi_signer: Arc<RwLock<dyn MultiSigner>>,
+}
+
+impl MithrilStakeDistributionSignableBuilder {
+    /// MithrilStakeDistribution signable builder factory
+    pub fn new(multi_signer: Arc<RwLock<dyn MultiSigner>>) -> Self {
+        Self { multi_signer }
+    }
+}
+
+#[async_trait]
+impl SignableBuilder<Epoch, ProtocolMessage> for MithrilStakeDistributionSignableBuilder {
+    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)
+    }
+}
+
+#[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)));
+        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(),
+        );
+        assert_eq!(signable_expected, signable);
+    }
+}

mithril-aggregator/src/signable_builder/mithril_stake_distribution.rs

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

mithril-aggregator/src/signable_builder/mod.rs

@@ -2,21 +2,24 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::SignedEntityType,
-    signable_builder::{DummyBeacon, DummySignableBuilder, Signable, SignableBuilder},
+    signable_builder::{Signable, SignableBuilder},
     StdResult,
 };
 
+use super::MithrilStakeDistributionSignableBuilder;
+
 /// SignableBuilder Service
-// TODO: temporary implementation
 pub struct SignableBuilderService {
-    dummy_signable_builder: DummySignableBuilder,
+    mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
 }
 
 impl SignableBuilderService {
     /// SignableBuilderService factory
-    pub fn new(dummy_signable_builder: DummySignableBuilder) -> Self {
+    pub fn new(
+        mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
+    ) -> Self {
         Self {
-            dummy_signable_builder,
+            mithril_stake_distribution_builder,
         }
     }
 }
@@ -29,8 +32,8 @@ impl SignableBuilderService {
     ) -> StdResult<Arc<dyn Signable>> {
         let signable: Arc<dyn Signable> = match signed_entity_type {
             SignedEntityType::MithrilStakeDistribution(e) => Arc::new(
-                self.dummy_signable_builder
-                    .compute_signable(DummyBeacon { epoch: e })
+                self.mithril_stake_distribution_builder
+                    .compute_signable(e)
                     .await?,
             ),
             _ => todo!(),