add signable builder in signer

mithril-aggregator/Cargo.toml

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

mithril-aggregator/src/dependency_injection/builder.rs

@@ -16,6 +16,7 @@ use mithril_common::{
         adapters::{EraReaderAdapterBuilder, EraReaderDummyAdapter},
         EraChecker, EraMarker, EraReader, EraReaderAdapter, SupportedEra,
     },
+    signable_builder::CardanoImmutableFilesFullSignableBuilder,
     store::adapter::{MemoryAdapter, SQLiteAdapter, StoreAdapter},
     BeaconProvider, BeaconProviderImpl,
 };
@@ -42,9 +43,7 @@ use crate::{
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
-    signable_builder::{
-        ImmutableSignableBuilder, MithrilStakeDistributionSignableBuilder, SignableBuilderService,
-    },
+    signable_builder::{MithrilStakeDistributionSignableBuilder, SignableBuilderService},
     signer_registerer::SignerRecorder,
     stake_distribution_service::{MithrilStakeDistributionService, StakeDistributionService},
     ticker_service::{MithrilTickerService, TickerService},
@@ -877,8 +876,10 @@ 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 immutable_signable_builder = CardanoImmutableFilesFullSignableBuilder::new(
+            self.get_immutable_digester().await?,
+            self.get_logger().await?,
+        );
         let signable_builder_service = Arc::new(SignableBuilderService::new(
             mithril_stake_distribution_builder,
             immutable_signable_builder,

mithril-aggregator/src/lib.rs

@@ -40,7 +40,7 @@ pub use crate::configuration::{
 };
 pub use crate::multi_signer::{MultiSigner, MultiSignerImpl, ProtocolError};
 pub use crate::signable_builder::{
-    ImmutableSignableBuilder, MithrilStakeDistributionSignableBuilder, SignableBuilderService,
+    MithrilStakeDistributionSignableBuilder, SignableBuilderService,
 };
 pub use crate::snapshot_stores::{LocalSnapshotStore, SnapshotStore};
 pub use command_args::MainOpts;

mithril-aggregator/src/signable_builder/mod.rs

@@ -1,9 +1,7 @@
 //! 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/signable_builder_service.rs

@@ -2,23 +2,23 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::SignedEntityType,
-    signable_builder::{Signable, SignableBuilder},
+    signable_builder::{CardanoImmutableFilesFullSignableBuilder, Signable, SignableBuilder},
     StdResult,
 };
 
-use super::{ImmutableSignableBuilder, MithrilStakeDistributionSignableBuilder};
+use super::MithrilStakeDistributionSignableBuilder;
 
 /// SignableBuilder Service
 pub struct SignableBuilderService {
     mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
-    immutable_signable_builder: ImmutableSignableBuilder,
+    immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder,
 }
 
 impl SignableBuilderService {
     /// SignableBuilderService factory
     pub fn new(
         mithril_stake_distribution_builder: MithrilStakeDistributionSignableBuilder,
-        immutable_signable_builder: ImmutableSignableBuilder,
+        immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder,
     ) -> Self {
         Self {
             mithril_stake_distribution_builder,

mithril-common/Cargo.toml

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

mithril-common/src/digesters/cache/json_provider.rs

@@ -261,7 +261,7 @@ mod tests {
 
     #[tokio::test]
     async fn reset_clear_existing_values() {
-        let file = get_test_dir("store_erase_existing_values").join("immutable-cache-store.json");
+        let file = get_test_dir("reset_clear_existing_values").join("immutable-cache-store.json");
         let provider = JsonImmutableFileDigestCacheProvider::new(&file);
         let values_to_store = vec![
             ("0.chunk".to_string(), "digest 0".to_string()),

mithril-aggregator/src/signable_builder/immutable_signable_builder.rs → mithril-common/src/signable_builder/cardano_immutable_full_signable_builder.rs

@@ -1,29 +1,36 @@
 use std::sync::Arc;
 
-use async_trait::async_trait;
-use mithril_common::{
+use crate::{
     digesters::ImmutableDigester,
     entities::{Beacon, ProtocolMessage, ProtocolMessagePartKey},
     signable_builder::SignableBuilder,
     StdResult,
 };
+use async_trait::async_trait;
+use slog::{debug, info, Logger};
 
-/// A [SignableBuilder] for cardano immutable files.
-pub struct ImmutableSignableBuilder {
+/// This structure is responsible of calculating the message for Cardano immutable files snapshots.
+pub struct CardanoImmutableFilesFullSignableBuilder {
     immutable_digester: Arc<dyn ImmutableDigester>,
+    logger: Logger,
 }
 
-impl ImmutableSignableBuilder {
+impl CardanoImmutableFilesFullSignableBuilder {
     /// Constructor
-    pub fn new(immutable_digester: Arc<dyn ImmutableDigester>) -> Self {
-        Self { immutable_digester }
+    pub fn new(immutable_digester: Arc<dyn ImmutableDigester>, logger: Logger) -> Self {
+        Self {
+            immutable_digester,
+            logger,
+        }
     }
 }
 
 #[async_trait]
-impl SignableBuilder<Beacon, ProtocolMessage> for ImmutableSignableBuilder {
+impl SignableBuilder<Beacon, ProtocolMessage> for CardanoImmutableFilesFullSignableBuilder {
     async fn compute_signable(&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}'.");
         let mut protocol_message = ProtocolMessage::new();
         protocol_message.set_message_part(ProtocolMessagePartKey::SnapshotDigest, digest);
 
@@ -35,9 +42,10 @@ impl SignableBuilder<Beacon, ProtocolMessage> for ImmutableSignableBuilder {
 mod tests {
     use super::*;
 
+    use crate::digesters::{ImmutableDigester, ImmutableDigesterError};
+    use crate::entities::Beacon;
     use async_trait::async_trait;
-    use mithril_common::digesters::{ImmutableDigester, ImmutableDigesterError};
-    use mithril_common::entities::Beacon;
+    use slog::Drain;
 
     #[derive(Default)]
     pub struct ImmutableDigesterImpl;
@@ -48,10 +56,18 @@ mod tests {
             Ok(format!("immutable {}", beacon.immutable_file_number))
         }
     }
+
+    fn create_logger() -> slog::Logger {
+        let decorator = slog_term::PlainDecorator::new(slog_term::TestStdoutWriter);
+        let drain = slog_term::CompactFormat::new(decorator).build().fuse();
+        let drain = slog_async::Async::new(drain).build().fuse();
+        slog::Logger::root(Arc::new(drain), slog::o!())
+    }
     #[tokio::test]
     async fn compute_signable() {
         let digester = ImmutableDigesterImpl::default();
-        let signable_builder = ImmutableSignableBuilder::new(Arc::new(digester));
+        let signable_builder =
+            CardanoImmutableFilesFullSignableBuilder::new(Arc::new(digester), create_logger());
         let protocol_message = signable_builder
             .compute_signable(Beacon::default())
             .await

mithril-common/src/signable_builder/mod.rs

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

mithril-signer/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-signer"
-version = "0.2.36"
+version = "0.2.37"
 description = "A Mithril Signer"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-signer/src/lib.rs

@@ -23,5 +23,5 @@ pub use message_adapters::{
 };
 pub use protocol_initializer_store::{ProtocolInitializerStore, ProtocolInitializerStorer};
 pub use runtime::*;
-pub use signable_builder::SignableBuilderService;
+pub use signable_builder::*;
 pub use single_signer::*;

mithril-signer/src/runtime/runner.rs

@@ -485,7 +485,7 @@ mod tests {
             adapters::{EraReaderAdapterType, EraReaderBootstrapAdapter},
             EraChecker, EraReader,
         },
-        signable_builder::DummySignableBuilder,
+        signable_builder::CardanoImmutableFilesFullSignableBuilder,
         store::{
             adapter::{DumbStoreAdapter, MemoryAdapter},
             StakeStore, StakeStorer,
@@ -533,16 +533,17 @@ mod tests {
         ));
 
         let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
+        let digester = Arc::new(DumbImmutableDigester::new(DIGESTER_RESULT, true));
+        let signable_builder =
+            CardanoImmutableFilesFullSignableBuilder::new(digester.clone(), slog_scope::logger());
 
-        let dummy_signable_builder = DummySignableBuilder::new();
-        let signable_builder_service =
-            Arc::new(SignableBuilderService::new(dummy_signable_builder));
+        let signable_builder_service = Arc::new(SignableBuilderService::new(signable_builder));
 
         SignerServices {
             stake_store: Arc::new(StakeStore::new(Box::new(DumbStoreAdapter::new()), None)),
             certificate_handler: Arc::new(DumbCertificateHandler::default()),
             chain_observer,
-            digester: Arc::new(DumbImmutableDigester::new(DIGESTER_RESULT, true)),
+            digester,
             single_signer: Arc::new(MithrilSingleSigner::new("1".to_string())),
             beacon_provider,
             protocol_initializer_store: Arc::new(ProtocolInitializerStore::new(

mithril-signer/src/runtime/signer_services.rs

@@ -14,15 +14,15 @@ use mithril_common::{
     },
     digesters::{CardanoImmutableDigester, ImmutableDigester, ImmutableFileSystemObserver},
     era::{EraChecker, EraReader},
-    signable_builder::DummySignableBuilder,
+    signable_builder::CardanoImmutableFilesFullSignableBuilder,
     store::{adapter::SQLiteAdapter, StakeStore},
     BeaconProvider, BeaconProviderImpl, StdError,
 };
 
 use crate::{
-    certificate_handler::CertificateHandler, signable_builder::SignableBuilderService,
-    single_signer::SingleSigner, CertificateHandlerHTTPClient, Configuration, MithrilSingleSigner,
-    ProtocolInitializerStore, ProtocolInitializerStorer,
+    certificate_handler::CertificateHandler, single_signer::SingleSigner,
+    CertificateHandlerHTTPClient, Configuration, MithrilSingleSigner, ProtocolInitializerStore,
+    ProtocolInitializerStorer, SignableBuilderService,
 };
 
 type StakeStoreService = Arc<StakeStore>;
@@ -201,7 +201,8 @@ impl<'a> ServiceBuilder for ProductionServiceBuilder<'a> {
             api_version_provider.clone(),
         ));
 
-        let dummy_signable_builder = DummySignableBuilder::new();
+        let dummy_signable_builder =
+            CardanoImmutableFilesFullSignableBuilder::new(digester.clone(), slog_scope::logger());
         let signable_builder_service =
             Arc::new(SignableBuilderService::new(dummy_signable_builder));
 

mithril-signer/src/signable_builder/signable_builder_service.rs

@@ -2,21 +2,21 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::SignedEntityType,
-    signable_builder::{DummyBeacon, DummySignableBuilder, Signable, SignableBuilder},
+    signable_builder::{CardanoImmutableFilesFullSignableBuilder, Signable, SignableBuilder},
     StdResult,
 };
 
 /// SignableBuilder Service
 // TODO: temporary implementation
 pub struct SignableBuilderService {
-    dummy_signable_builder: DummySignableBuilder,
+    immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder,
 }
 
 impl SignableBuilderService {
     /// SignableBuilderService factory
-    pub fn new(dummy_signable_builder: DummySignableBuilder) -> Self {
+    pub fn new(immutable_signable_builder: CardanoImmutableFilesFullSignableBuilder) -> Self {
         Self {
-            dummy_signable_builder,
+            immutable_signable_builder,
         }
     }
 }
@@ -28,9 +28,9 @@ impl SignableBuilderService {
         signed_entity_type: SignedEntityType,
     ) -> 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 })
+            SignedEntityType::CardanoImmutableFilesFull(beacon) => Arc::new(
+                self.immutable_signable_builder
+                    .compute_signable(beacon)
                     .await?,
             ),
             _ => todo!(),

mithril-signer/tests/test_extensions/state_machine_tester.rs

@@ -7,7 +7,7 @@ use mithril_common::era::{
     EraChecker, EraReader,
 };
 use mithril_common::era::{EraMarker, SupportedEra};
-use mithril_common::signable_builder::DummySignableBuilder;
+use mithril_common::signable_builder::CardanoImmutableFilesFullSignableBuilder;
 use mithril_common::BeaconProvider;
 use slog::Drain;
 use slog_scope::debug;
@@ -150,9 +150,9 @@ impl StateMachineTester {
 
         let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
 
-        let dummy_signable_builder = DummySignableBuilder::new();
-        let signable_builder_service =
-            Arc::new(SignableBuilderService::new(dummy_signable_builder));
+        let signable_builder =
+            CardanoImmutableFilesFullSignableBuilder::new(digester.clone(), slog_scope::logger());
+        let signable_builder_service = Arc::new(SignableBuilderService::new(signable_builder));
 
         let services = SignerServices {
             certificate_handler: certificate_handler.clone(),