Merge pull request input-output-hk#1763 from input-output-hk/ensemble…

…/1692/warmup_cardano_transaction

Warmup/Preload cardano transactions & block range roots

CHANGELOG.md

@@ -20,6 +20,7 @@ As a minor extension, we have adopted a slightly different versioning convention
 - **UNSTABLE** Cardano transactions certification:
   - Optimize the performances of the computation of the proof with a Merkle map.
   - Handle rollback events from the Cardano chain by removing stale data.
+  - Preload Cardano transactions and Block Range Roots at signer & aggregator startup.
 
 - Crates versions:
 

mithril-aggregator/Cargo.toml

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

mithril-aggregator/src/commands/serve_command.rs

@@ -119,6 +119,16 @@ impl ServeCommand {
         let mut join_set = JoinSet::new();
         join_set.spawn(async move { runtime.run().await.map_err(|e| e.to_string()) });
 
+        // start the cardano transactions preloader
+        let cardano_transactions_preloader = dependencies_builder
+            .create_cardano_transactions_preloader()
+            .await
+            .with_context(|| {
+                "Dependencies Builder can not create cardano transactions preloader"
+            })?;
+        let preload_task =
+            tokio::spawn(async move { cardano_transactions_preloader.preload().await });
+
         // start the HTTP server
         let (shutdown_tx, shutdown_rx) = oneshot::channel();
         let routes = dependencies_builder
@@ -180,6 +190,10 @@ impl ServeCommand {
         join_set.shutdown().await;
         let _ = shutdown_tx.send(());
 
+        if !preload_task.is_finished() {
+            preload_task.abort();
+        }
+
         info!("Event store is finishing...");
         event_store_thread.await.unwrap();
         println!("Services stopped, exiting.");

mithril-aggregator/src/dependency_injection/builder.rs

@@ -14,6 +14,7 @@ use warp::Filter;
 use mithril_common::{
     api_version::APIVersionProvider,
     cardano_block_scanner::{BlockScanner, CardanoBlockScanner},
+    cardano_transactions_preloader::CardanoTransactionsPreloader,
     certificate_chain::{CertificateVerifier, MithrilCertificateVerifier},
     chain_observer::{CardanoCliRunner, ChainObserver, ChainObserverBuilder, FakeObserver},
     crypto_helper::{
@@ -32,7 +33,7 @@ use mithril_common::{
     signable_builder::{
         CardanoImmutableFilesFullSignableBuilder, CardanoTransactionsSignableBuilder,
         MithrilSignableBuilderService, MithrilStakeDistributionSignableBuilder,
-        SignableBuilderService,
+        SignableBuilderService, TransactionsImporter,
     },
     signed_entity_type_lock::SignedEntityTypeLock,
     MithrilTickerService, TickerService,
@@ -210,6 +211,12 @@ pub struct DependenciesBuilder {
 
     /// Prover service
     pub prover_service: Option<Arc<dyn ProverService>>,
+
+    /// Signed Entity Type Lock
+    pub signed_entity_type_lock: Option<Arc<SignedEntityTypeLock>>,
+
+    /// Transactions Importer
+    pub transactions_importer: Option<Arc<dyn TransactionsImporter>>,
 }
 
 impl DependenciesBuilder {
@@ -256,6 +263,8 @@ impl DependenciesBuilder {
             signed_entity_storer: None,
             message_service: None,
             prover_service: None,
+            signed_entity_type_lock: None,
+            transactions_importer: None,
         }
     }
 
@@ -1028,12 +1037,7 @@ impl DependenciesBuilder {
             &self.configuration.db_directory,
             self.get_logger().await?,
         ));
-        let transactions_importer = Arc::new(CardanoTransactionsImporter::new(
-            self.get_block_scanner().await?,
-            self.get_transaction_repository().await?,
-            &self.configuration.db_directory,
-            self.get_logger().await?,
-        ));
+        let transactions_importer = self.get_transactions_importer().await?;
         let block_range_root_retriever = self.get_transaction_repository().await?;
         let cardano_transactions_builder = Arc::new(CardanoTransactionsSignableBuilder::new(
             transactions_importer,
@@ -1149,6 +1153,38 @@ impl DependenciesBuilder {
         Ok(self.signed_entity_storer.as_ref().cloned().unwrap())
     }
 
+    async fn build_signed_entity_lock(&mut self) -> Result<Arc<SignedEntityTypeLock>> {
+        let signed_entity_type_lock = Arc::new(SignedEntityTypeLock::default());
+        Ok(signed_entity_type_lock)
+    }
+
+    async fn get_signed_entity_lock(&mut self) -> Result<Arc<SignedEntityTypeLock>> {
+        if self.signed_entity_type_lock.is_none() {
+            self.signed_entity_type_lock = Some(self.build_signed_entity_lock().await?);
+        }
+
+        Ok(self.signed_entity_type_lock.as_ref().cloned().unwrap())
+    }
+
+    async fn build_transactions_importer(&mut self) -> Result<Arc<dyn TransactionsImporter>> {
+        let transactions_importer = Arc::new(CardanoTransactionsImporter::new(
+            self.get_block_scanner().await?,
+            self.get_transaction_repository().await?,
+            &self.configuration.db_directory,
+            self.get_logger().await?,
+        ));
+
+        Ok(transactions_importer)
+    }
+
+    async fn get_transactions_importer(&mut self) -> Result<Arc<dyn TransactionsImporter>> {
+        if self.transactions_importer.is_none() {
+            self.transactions_importer = Some(self.build_transactions_importer().await?);
+        }
+
+        Ok(self.transactions_importer.as_ref().cloned().unwrap())
+    }
+
     /// Return an unconfigured [DependencyContainer]
     pub async fn build_dependency_container(&mut self) -> Result<DependencyContainer> {
         let dependency_manager = DependencyContainer {
@@ -1189,7 +1225,7 @@ impl DependenciesBuilder {
             block_scanner: self.get_block_scanner().await?,
             transaction_store: self.get_transaction_repository().await?,
             prover_service: self.get_prover_service().await?,
-            signed_entity_type_lock: Arc::new(SignedEntityTypeLock::default()),
+            signed_entity_type_lock: self.get_signed_entity_lock().await?,
         };
 
         Ok(dependency_manager)
@@ -1233,6 +1269,23 @@ impl DependenciesBuilder {
         Ok(router::routes(dependency_container))
     }
 
+    /// Create a [CardanoTransactionsPreloader] instance.
+    pub async fn create_cardano_transactions_preloader(
+        &mut self,
+    ) -> Result<Arc<CardanoTransactionsPreloader>> {
+        let cardano_transactions_preloader = CardanoTransactionsPreloader::new(
+            self.get_signed_entity_lock().await?,
+            self.get_transactions_importer().await?,
+            self.configuration
+                .cardano_transactions_signing_config
+                .security_parameter,
+            self.get_chain_observer().await?,
+            self.get_logger().await?,
+        );
+
+        Ok(Arc::new(cardano_transactions_preloader))
+    }
+
     /// Create dependencies for genesis commands
     pub async fn create_genesis_container(&mut self) -> Result<GenesisToolsDependency> {
         let network = self.configuration.get_network().with_context(|| {

mithril-aggregator/src/dependency_injection/containers.rs

@@ -1,15 +1,14 @@
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use mithril_common::entities::SignedEntityConfig;
 use mithril_common::{
     api_version::APIVersionProvider,
     cardano_block_scanner::BlockScanner,
     certificate_chain::CertificateVerifier,
     chain_observer::ChainObserver,
     crypto_helper::ProtocolGenesisVerifier,
     digesters::{ImmutableDigester, ImmutableFileObserver},
-    entities::{Epoch, ProtocolParameters, SignerWithStake, StakeDistribution},
+    entities::{Epoch, ProtocolParameters, SignedEntityConfig, SignerWithStake, StakeDistribution},
     era::{EraChecker, EraReader},
     signable_builder::SignableBuilderService,
     signed_entity_type_lock::SignedEntityTypeLock,

mithril-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.4.17"
+version = "0.4.18"
 description = "Common types, interfaces, and utilities for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }