mithril_aggregator/dependency_injection/builder/support/
stores.rs

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

mithril_aggregator/dependency_injection/builder/support/
stores.rs
