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;
5
6use crate::configuration::BlockfrostParameters;
7use crate::database::repository::{
8    AggregatorCardanoChainDataRepository, CertificateRepository, EpochSettingsStore,
9    ImmutableFileDigestRepository, OpenMessageRepository, SignedEntityStore, SignedEntityStorer,
10    SignerRegistrationStore, SignerStore, StakePoolStore,
11};
12use crate::dependency_injection::{DependenciesBuilder, Result};
13use crate::tools::signer_importer::{BlockfrostSignerRetriever, SignersImporter};
14use crate::{
15    ImmutableFileDigestMapper, ProtocolParametersRetriever, VerificationKeyStorer, get_dependency,
16};
17
18impl DependenciesBuilder {
19    async fn build_stake_store(&mut self) -> Result<Arc<StakePoolStore>> {
20        let stake_pool_store = Arc::new(StakePoolStore::new(
21            self.get_sqlite_connection().await?,
22            self.configuration.safe_epoch_retention_limit(),
23        ));
24
25        Ok(stake_pool_store)
26    }
27
28    /// Return a [StakePoolStore]
29    pub async fn get_stake_store(&mut self) -> Result<Arc<StakePoolStore>> {
30        get_dependency!(self.stake_store)
31    }
32
33    async fn build_certificate_repository(&mut self) -> Result<Arc<CertificateRepository>> {
34        Ok(Arc::new(CertificateRepository::new(
35            self.get_sqlite_connection().await?,
36        )))
37    }
38
39    /// Get a configured [CertificateRepository].
40    pub async fn get_certificate_repository(&mut self) -> Result<Arc<CertificateRepository>> {
41        get_dependency!(self.certificate_repository)
42    }
43
44    async fn build_open_message_repository(&mut self) -> Result<Arc<OpenMessageRepository>> {
45        Ok(Arc::new(OpenMessageRepository::new(
46            self.get_sqlite_connection().await?,
47        )))
48    }
49
50    /// Get a configured [OpenMessageRepository].
51    pub async fn get_open_message_repository(&mut self) -> Result<Arc<OpenMessageRepository>> {
52        get_dependency!(self.open_message_repository)
53    }
54
55    async fn build_verification_key_store(&mut self) -> Result<Arc<dyn VerificationKeyStorer>> {
56        Ok(Arc::new(SignerRegistrationStore::new(
57            self.get_sqlite_connection().await?,
58            self.configuration.safe_epoch_retention_limit(),
59        )))
60    }
61
62    /// Get a configured [VerificationKeyStorer].
63    pub async fn get_verification_key_store(&mut self) -> Result<Arc<dyn VerificationKeyStorer>> {
64        get_dependency!(self.verification_key_store)
65    }
66
67    async fn build_protocol_parameters_retriever(
68        &mut self,
69    ) -> Result<Arc<dyn ProtocolParametersRetriever>> {
70        let protocol_parameters_retriever =
71            EpochSettingsStore::new(self.get_sqlite_connection().await?, None);
72
73        Ok(Arc::new(protocol_parameters_retriever))
74    }
75
76    /// Get a configured [ProtocolParametersRetriever].
77    pub async fn get_protocol_parameters_retriever(
78        &mut self,
79    ) -> Result<Arc<dyn ProtocolParametersRetriever>> {
80        if self.protocol_parameters_retriever.is_none() {
81            self.protocol_parameters_retriever =
82                Some(self.build_protocol_parameters_retriever().await?);
83        }
84
85        Ok(self.protocol_parameters_retriever.as_ref().cloned().unwrap())
86    }
87
88    async fn build_epoch_settings_store(&mut self) -> Result<Arc<EpochSettingsStore>> {
89        let epoch_settings_store = EpochSettingsStore::new(
90            self.get_sqlite_connection().await?,
91            self.configuration.safe_epoch_retention_limit(),
92        );
93
94        Ok(Arc::new(epoch_settings_store))
95    }
96
97    /// Get a configured [EpochSettingsStore].
98    pub async fn get_epoch_settings_store(&mut self) -> Result<Arc<EpochSettingsStore>> {
99        get_dependency!(self.epoch_settings_store)
100    }
101
102    async fn build_immutable_cache_provider(
103        &mut self,
104    ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>> {
105        let cache_provider =
106            ImmutableFileDigestRepository::new(self.get_sqlite_connection().await?);
107        if self.configuration.reset_digests_cache() {
108            cache_provider
109                .reset()
110                .await
111                .with_context(|| "Failure occurred when resetting immutable file digest cache")?;
112        }
113
114        Ok(Arc::new(cache_provider))
115    }
116
117    /// Get an [ImmutableFileDigestCacheProvider]
118    pub async fn get_immutable_cache_provider(
119        &mut self,
120    ) -> Result<Arc<dyn ImmutableFileDigestCacheProvider>> {
121        get_dependency!(self.immutable_cache_provider)
122    }
123
124    async fn build_chain_data_repository(
125        &mut self,
126    ) -> Result<Arc<AggregatorCardanoChainDataRepository>> {
127        let chain_data_repository = AggregatorCardanoChainDataRepository::new(
128            self.get_sqlite_connection_cardano_transaction_pool().await?,
129        );
130
131        Ok(Arc::new(chain_data_repository))
132    }
133
134    /// Transaction repository.
135    pub async fn get_chain_data_repository(
136        &mut self,
137    ) -> Result<Arc<AggregatorCardanoChainDataRepository>> {
138        get_dependency!(self.chain_data_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 signers importer instance.
180    pub async fn create_blockfrost_signer_importer(
181        &mut self,
182        parameters: &BlockfrostParameters,
183    ) -> Result<SignersImporter> {
184        let retriever = BlockfrostSignerRetriever::new(
185            parameters.project_id.expose_secret(),
186            parameters.base_url.clone(),
187        );
188        let persister = self.get_signer_store().await?;
189
190        Ok(SignersImporter::new(
191            Arc::new(retriever),
192            persister,
193            self.root_logger(),
194        ))
195    }
196}
mithril_aggregator/dependency_injection/builder/support/stores.rs

mithril_aggregator/dependency_injection/builder/support/
stores.rs
