Merge pull request #865 from input-output-hk/ensemble/847-signable-artifact-builder

Implement Signable & Artifact Builders

Author: jpraynaud

Cargo.lock

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

mithril-aggregator/Cargo.toml

@@ -0,0 +1,93 @@
+use std::sync::Arc;
+
+use mithril_common::{
+    entities::{Certificate, SignedEntityType},
+    signable_builder::DummyBeacon,
+    StdResult,
+};
+
+use crate::artifact_builder::{Artifact, DummyArtifactBuilder};
+
+use super::ArtifactBuilder;
+
+/// ArtifactBuilder Service
+// TODO: temporary implementation
+pub struct ArtifactBuilderService {
+    dummy_artifact_builder: DummyArtifactBuilder,
+}
+
+impl ArtifactBuilderService {
+    /// ArtifactBuilderService factory
+    #[allow(dead_code)]
+    pub fn new(dummy_artifact_builder: DummyArtifactBuilder) -> Self {
+        Self {
+            dummy_artifact_builder,
+        }
+    }
+}
+
+impl ArtifactBuilderService {
+    #[allow(dead_code)]
+    async fn compute_artifact(
+        &self,
+        signed_entity_type: SignedEntityType,
+        certificate: &Certificate,
+    ) -> StdResult<Arc<impl Artifact>> {
+        let artifact = match signed_entity_type {
+            SignedEntityType::MithrilStakeDistribution(e) => Arc::new(
+                self.dummy_artifact_builder
+                    .compute_artifact(DummyBeacon { epoch: e }, certificate)
+                    .await?,
+            ),
+            SignedEntityType::CardanoStakeDistribution(e) => Arc::new(
+                self.dummy_artifact_builder
+                    .compute_artifact(DummyBeacon { epoch: e }, certificate)
+                    .await?,
+            ),
+            SignedEntityType::CardanoImmutableFilesFull(b) => Arc::new(
+                self.dummy_artifact_builder
+                    .compute_artifact(DummyBeacon { epoch: b.epoch }, certificate)
+                    .await?,
+            ),
+        };
+
+        Ok(artifact)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use mithril_common::entities::{Beacon, Epoch};
+
+    use super::*;
+
+    // TODO: temporary test
+    #[tokio::test]
+    async fn test_artifact_builder_service() {
+        let dummy_artifact_builder = DummyArtifactBuilder::default();
+        let artifact_builder_service = ArtifactBuilderService::new(dummy_artifact_builder);
+        let certificate = Certificate::default();
+
+        let signed_entity_type_1 = SignedEntityType::MithrilStakeDistribution(Epoch(1));
+        let artifact_1 = artifact_builder_service
+            .compute_artifact(signed_entity_type_1, &certificate)
+            .await
+            .unwrap();
+
+        let signed_entity_type_2 = SignedEntityType::CardanoStakeDistribution(Epoch(0));
+        let artifact_2 = artifact_builder_service
+            .compute_artifact(signed_entity_type_2, &certificate)
+            .await
+            .unwrap();
+
+        let signed_entity_type_3 = SignedEntityType::CardanoImmutableFilesFull(Beacon::default());
+        let artifact_3 = artifact_builder_service
+            .compute_artifact(signed_entity_type_3, &certificate)
+            .await
+            .unwrap();
+
+        assert_ne!(artifact_1, artifact_2);
+        assert_ne!(artifact_1, artifact_3);
+        assert_eq!(artifact_2, artifact_3);
+    }
+}

mithril-aggregator/src/artifact_builder/artifact_builder_service.rs

@@ -0,0 +1,58 @@
+use std::marker::PhantomData;
+
+use async_trait::async_trait;
+use mithril_common::{entities::Certificate, signable_builder::DummyBeacon, StdResult};
+use serde::{Deserialize, Serialize};
+
+use crate::artifact_builder::{Artifact, ArtifactBuilder};
+
+/// Dummy artifact
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct DummyArtifact<'a> {
+    message: String,
+    beacon: DummyBeacon,
+    phantom: PhantomData<&'a DummyBeacon>,
+}
+
+impl<'a> DummyArtifact<'a> {
+    /// Dummy artifact factory
+    pub fn new(message: String, beacon: DummyBeacon) -> Self {
+        Self {
+            message,
+            beacon,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a> Artifact<'a> for DummyArtifact<'a> {}
+
+/// A [DummyArtifact] builder
+pub struct DummyArtifactBuilder {}
+
+impl DummyArtifactBuilder {
+    /// Dummy artifact builder factory
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Default for DummyArtifactBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl<'a> ArtifactBuilder<'a, DummyBeacon, DummyArtifact<'a>> for DummyArtifactBuilder {
+    async fn compute_artifact(
+        &'a self,
+        beacon: DummyBeacon,
+        certificate: &Certificate,
+    ) -> StdResult<DummyArtifact> {
+        Ok(DummyArtifact::new(
+            format!("certificate id is {}", certificate.hash),
+            beacon,
+        ))
+    }
+}

mithril-aggregator/src/artifact_builder/dummy_artifact.rs

@@ -0,0 +1,18 @@
+use async_trait::async_trait;
+use mithril_common::{entities::Certificate, signable_builder::Beacon, StdResult};
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+/// Artifact is a trait for types that represent signed artifacts
+pub trait Artifact<'a>: Serialize + Deserialize<'a> + PartialEq + Debug {}
+
+/// ArtifactBuilder is trait for building an artifact
+#[async_trait]
+pub trait ArtifactBuilder<'a, U, W>
+where
+    U: Beacon,
+    W: Artifact<'a>,
+{
+    /// Compute an artifact
+    async fn compute_artifact(&'a self, beacon: U, certificate: &Certificate) -> StdResult<W>;
+}

mithril-aggregator/src/artifact_builder/interface.rs

@@ -0,0 +1,9 @@
+//! The module used for building artifact
+
+mod artifact_builder_service;
+mod dummy_artifact;
+mod interface;
+
+pub use artifact_builder_service::*;
+pub use dummy_artifact::*;
+pub use interface::*;

mithril-aggregator/src/artifact_builder/mod.rs

@@ -15,7 +15,8 @@ use std::{collections::HashMap, sync::Arc};
 use tokio::sync::{Mutex, RwLock};
 
 use crate::{
-    configuration::*, database::provider::StakePoolStore, signer_registerer::SignerRecorder,
+    artifact_builder::ArtifactBuilderService, configuration::*, database::provider::StakePoolStore,
+    signable_builder::SignableBuilderService, signer_registerer::SignerRecorder,
     CertificatePendingStore, CertificateStore, ProtocolParametersStore, ProtocolParametersStorer,
     SignerRegisterer, SignerRegistrationRoundOpener, SingleSignatureStore, Snapshotter,
     VerificationKeyStore, VerificationKeyStorer,
@@ -111,6 +112,12 @@ pub struct DependencyManager {
 
     /// Signer Recorder
     pub signer_recorder: Arc<dyn SignerRecorder>,
+
+    /// Signable Builder Service
+    pub signable_builder_service: Arc<SignableBuilderService>,
+
+    /// Artifact Builder Service
+    pub artifact_builder_service: Arc<ArtifactBuilderService>,
 }
 
 #[doc(hidden)]

mithril-aggregator/src/dependency.rs

@@ -19,6 +19,7 @@ use mithril_common::{
         adapters::{EraReaderAdapterBuilder, EraReaderDummyAdapter},
         EraChecker, EraMarker, EraReader, EraReaderAdapter, SupportedEra,
     },
+    signable_builder::DummySignableBuilder,
     store::adapter::{MemoryAdapter, SQLiteAdapter, StoreAdapter},
     BeaconProvider, BeaconProviderImpl,
 };
@@ -35,13 +36,15 @@ use tokio::{
 use warp::Filter;
 
 use crate::{
+    artifact_builder::{ArtifactBuilderService, DummyArtifactBuilder},
     configuration::{ExecutionEnvironment, LIST_SNAPSHOTS_MAX_ITEMS},
     database::provider::{
         CertificateStoreAdapter, EpochSettingStore, SignedEntityStoreAdapter,
         SignerRegistrationStoreAdapter, SignerStore, StakePoolStore,
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
+    signable_builder::SignableBuilderService,
     signer_registerer::SignerRecorder,
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     ticker_service::{MithrilTickerService, TickerService},
@@ -156,6 +159,12 @@ pub struct DependenciesBuilder {
 
     /// Signer Recorder
     pub signer_recorder: Option<Arc<dyn SignerRecorder>>,
+
+    /// Signable Builder Service
+    pub signable_builder_service: Option<Arc<SignableBuilderService>>,
+
+    /// Artifact Builder Service
+    pub artifact_builder_service: Option<Arc<ArtifactBuilderService>>,
 }
 
 impl DependenciesBuilder {
@@ -193,6 +202,8 @@ impl DependenciesBuilder {
             stake_distribution_service: None,
             ticker_service: None,
             signer_recorder: None,
+            signable_builder_service: None,
+            artifact_builder_service: None,
         }
     }
 
@@ -968,6 +979,40 @@ impl DependenciesBuilder {
         Ok(self.signer_recorder.as_ref().cloned().unwrap())
     }
 
+    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));
+
+        Ok(signable_builder_service)
+    }
+
+    /// [SignableBuilderService] service
+    pub async fn get_signable_builder_service(&mut self) -> Result<Arc<SignableBuilderService>> {
+        if self.signable_builder_service.is_none() {
+            self.signable_builder_service = Some(self.build_signable_builder_service().await?);
+        }
+
+        Ok(self.signable_builder_service.as_ref().cloned().unwrap())
+    }
+
+    async fn build_artifact_builder_service(&mut self) -> Result<Arc<ArtifactBuilderService>> {
+        let dummy_artifact_builder = DummyArtifactBuilder::new();
+        let artifact_builder_service =
+            Arc::new(ArtifactBuilderService::new(dummy_artifact_builder));
+
+        Ok(artifact_builder_service)
+    }
+
+    /// [ArtifactBuilderService] service
+    pub async fn get_artifact_builder_service(&mut self) -> Result<Arc<ArtifactBuilderService>> {
+        if self.artifact_builder_service.is_none() {
+            self.artifact_builder_service = Some(self.build_artifact_builder_service().await?);
+        }
+
+        Ok(self.artifact_builder_service.as_ref().cloned().unwrap())
+    }
+
     /// Return an unconfigured [DependencyManager]
     pub async fn build_dependency_container(&mut self) -> Result<DependencyManager> {
         let dependency_manager = DependencyManager {
@@ -997,6 +1042,8 @@ impl DependenciesBuilder {
             api_version_provider: self.get_api_version_provider().await?,
             stake_distribution_service: self.get_stake_distribution_service().await?,
             signer_recorder: self.get_signer_recorder().await?,
+            signable_builder_service: self.get_signable_builder_service().await?,
+            artifact_builder_service: self.get_artifact_builder_service().await?,
         };
 
         Ok(dependency_manager)

mithril-aggregator/src/dependency_injection/builder.rs

@@ -11,6 +11,7 @@
 //! signed certificates.
 //! You can find more information on how it works reading the [documentation website](https://mithril.network/doc/mithril/mithril-network/aggregator).
 
+mod artifact_builder;
 mod certificate_creator;
 mod command_args;
 mod configuration;
@@ -22,6 +23,7 @@ mod http_server;
 mod message_adapters;
 mod multi_signer;
 mod runtime;
+mod signable_builder;
 mod signer_registerer;
 mod snapshot_stores;
 mod snapshot_uploaders;

mithril-aggregator/src/lib.rs

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