mithril_aggregator/dependency_injection/builder/support/
stores.rs

1use anyhow::Context;
2use std::sync::Arc;
3use std::time::Duration;
4
5use mithril_cardano_node_internal_database::digesters::cache::ImmutableFileDigestCacheProvider;
6use mithril_persistence::database::repository::CardanoTransactionRepository;
7
8use crate::database::repository::{
9    CertificateRepository, EpochSettingsStore, ImmutableFileDigestRepository,
10    OpenMessageRepository, SignedEntityStore, SignedEntityStorer, SignerRegistrationStore,
11    SignerStore, StakePoolStore,
12};
13use crate::dependency_injection::{DependenciesBuilder, Result};
14use crate::get_dependency;
15use crate::{
16    CExplorerSignerRetriever, ImmutableFileDigestMapper, ProtocolParametersRetriever,
17    SignersImporter, VerificationKeyStorer,
18};
19
20impl DependenciesBuilder {
21    async fn build_stake_store(&mut self) -> Result<Arc<StakePoolStore>> {
22        let stake_pool_store = Arc::new(StakePoolStore::new(
23            self.get_sqlite_connection().await?,
24            self.configuration.safe_epoch_retention_limit(),
25        ));
26
27        Ok(stake_pool_store)
28    }
29
30    /// Return a [StakePoolStore]
31    pub async fn get_stake_store(&mut self) -> Result<Arc<StakePoolStore>> {
32        get_dependency!(self.stake_store)
33    }
34
35    async fn build_certificate_repository(&mut self) -> Result<Arc<CertificateRepository>> {
36        Ok(Arc::new(CertificateRepository::new(
37            self.get_sqlite_connection().await?,
38        )))
39    }
40
41    /// Get a configured [CertificateRepository].
42    pub async fn get_certificate_repository(&mut self) -> Result<Arc<CertificateRepository>> {
43        get_dependency!(self.certificate_repository)
44    }
45
46    async fn build_open_message_repository(&mut self) -> Result<Arc<OpenMessageRepository>> {
47        Ok(Arc::new(OpenMessageRepository::new(
48            self.get_sqlite_connection().await?,
49        )))
50    }
51
52    /// Get a configured [OpenMessageRepository].
53    pub async fn get_open_message_repository(&mut self) -> Result<Arc<OpenMessageRepository>> {
54        get_dependency!(self.open_message_repository)
55    }
56
57    async fn build_verification_key_store(&mut self) -> Result<Arc<dyn VerificationKeyStorer>> {
58        Ok(Arc::new(SignerRegistrationStore::new(
59            self.get_sqlite_connection().await?,
60            self.configuration.safe_epoch_retention_limit(),
61        )))
62    }
63
64    /// Get a configured [VerificationKeyStorer].
65    pub async fn get_verification_key_store(&mut self) -> Result<Arc<dyn VerificationKeyStorer>> {
66        get_dependency!(self.verification_key_store)
67    }
68
69    async fn build_protocol_parameters_retriever(
70        &mut self,
71    ) -> Result<Arc<dyn ProtocolParametersRetriever>> {
72        let protocol_parameters_retriever =
73            EpochSettingsStore::new(self.get_sqlite_connection().await?, None);
74
75        Ok(Arc::new(protocol_parameters_retriever))
76    }
77
78    /// Get a configured [ProtocolParametersRetriever].
79    pub async fn get_protocol_parameters_retriever(
80        &mut self,
81    ) -> Result<Arc<dyn ProtocolParametersRetriever>> {
82        if self.protocol_parameters_retriever.is_none() {
83            self.protocol_parameters_retriever =
84                Some(self.build_protocol_parameters_retriever().await?);
85        }
86
87        Ok(self.protocol_parameters_retriever.as_ref().cloned().unwrap())
88    }
89
90    async fn build_epoch_settings_store(&mut self) -> Result<Arc<EpochSettingsStore>> {
91        let epoch_settings_store = EpochSettingsStore::new(
92            self.get_sqlite_connection().await?,
93            self.configuration.safe_epoch_retention_limit(),
94        );
95
96        Ok(Arc::new(epoch_settings_store))
97    }
98
99    /// Get a configured [EpochSettingsStore].
100    pub async fn get_epoch_settings_store(&mut self) -> Result<Arc<EpochSettingsStore>> {
101        get_dependency!(self.epoch_settings_store)
102    }
103
104    async fn build_immutable_cache_provider(
105        &mut self,
106    ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>> {
107        let cache_provider =
108            ImmutableFileDigestRepository::new(self.get_sqlite_connection().await?);
109        if self.configuration.reset_digests_cache() {
110            cache_provider
111                .reset()
112                .await
113                .with_context(|| "Failure occurred when resetting immutable file digest cache")?;
114        }
115
116        Ok(Arc::new(cache_provider))
117    }
118
119    /// Get an [ImmutableFileDigestCacheProvider]
120    pub async fn get_immutable_cache_provider(
121        &mut self,
122    ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>> {
123        get_dependency!(self.immutable_cache_provider)
124    }
125
126    async fn build_transaction_repository(&mut self) -> Result<Arc<CardanoTransactionRepository>> {
127        let transaction_store = CardanoTransactionRepository::new(
128            self.get_sqlite_connection_cardano_transaction_pool().await?,
129        );
130
131        Ok(Arc::new(transaction_store))
132    }
133
134    /// Transaction repository.
135    pub async fn get_transaction_repository(
136        &mut self,
137    ) -> Result<Arc<CardanoTransactionRepository>> {
138        get_dependency!(self.transaction_repository)
139    }
140
141    async fn build_immutable_file_digest_mapper(
142        &mut self,
143    ) -> Result<Arc<dyn ImmutableFileDigestMapper>> {
144        let mapper = ImmutableFileDigestRepository::new(self.get_sqlite_connection().await?);
145
146        Ok(Arc::new(mapper))
147    }
148
149    /// Immutable digest mapper.
150    pub async fn get_immutable_file_digest_mapper(
151        &mut self,
152    ) -> Result<Arc<dyn ImmutableFileDigestMapper>> {
153        get_dependency!(self.immutable_file_digest_mapper)
154    }
155
156    async fn build_signer_store(&mut self) -> Result<Arc<SignerStore>> {
157        let signer_store = Arc::new(SignerStore::new(self.get_sqlite_connection().await?));
158
159        Ok(signer_store)
160    }
161
162    /// [SignerStore] service
163    pub async fn get_signer_store(&mut self) -> Result<Arc<SignerStore>> {
164        get_dependency!(self.signer_store)
165    }
166
167    async fn build_signed_entity_storer(&mut self) -> Result<Arc<dyn SignedEntityStorer>> {
168        let signed_entity_storer =
169            Arc::new(SignedEntityStore::new(self.get_sqlite_connection().await?));
170
171        Ok(signed_entity_storer)
172    }
173
174    /// [SignedEntityStorer] service
175    pub async fn get_signed_entity_storer(&mut self) -> Result<Arc<dyn SignedEntityStorer>> {
176        get_dependency!(self.signed_entity_storer)
177    }
178
179    /// Create a [SignersImporter] instance.
180    pub async fn create_signer_importer(
181        &mut self,
182        cexplorer_pools_url: &str,
183    ) -> Result<SignersImporter> {
184        let retriever = CExplorerSignerRetriever::new(
185            cexplorer_pools_url,
186            Some(Duration::from_secs(30)),
187            self.root_logger(),
188        )?;
189        let persister = self.get_signer_store().await?;
190
191        Ok(SignersImporter::new(
192            Arc::new(retriever),
193            persister,
194            self.root_logger(),
195        ))
196    }
197}
mithril_aggregator/dependency_injection/builder/support/stores.rs

mithril_aggregator/dependency_injection/builder/support/
stores.rs
