mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs

1use anyhow::Context;
2use std::sync::Arc;
3
4use mithril_common::certificate_chain::{CertificateVerifier, MithrilCertificateVerifier};
5use mithril_common::crypto_helper::{
6    ProtocolGenesisSigner, ProtocolGenesisVerificationKey, ProtocolGenesisVerifier,
7};
8
9use crate::database::repository::{BufferedSingleSignatureRepository, SingleSignatureRepository};
10use crate::dependency_injection::{DependenciesBuilder, DependenciesBuilderError, Result};
11use crate::get_dependency;
12use crate::services::{
13    BufferedCertifierService, CertificateChainSynchronizer, CertifierService,
14    MithrilCertificateChainSynchronizer, MithrilCertificateChainSynchronizerNoop,
15    MithrilCertifierService, MithrilSignerRegistrationFollower, SignerSynchronizer,
16};
17use crate::{
18    ExecutionEnvironment, MithrilSignerRegistrationLeader, MithrilSignerRegistrationVerifier,
19    MultiSigner, MultiSignerImpl, SignerRegisterer, SignerRegistrationRoundOpener,
20    SignerRegistrationVerifier, SingleSignatureAuthenticator,
21};
22
23/// Retrieve the mithril_signer_registration according to the configuration.
24/// The macro is used because we are not able to return different kind of trait using a function.
25macro_rules! get_mithril_signer_registration {
26    ($self:ident) => {{
27        if $self.configuration.is_follower_aggregator() {
28            $self.get_mithril_signer_registration_follower().await?
29        } else {
30            $self.get_mithril_signer_registration_leader().await?
31        }
32    }};
33}
34
35impl DependenciesBuilder {
36    /// Create [CertifierService] service
37    pub async fn build_certifier_service(&mut self) -> Result<Arc<dyn CertifierService>> {
38        let cardano_network = self.configuration.get_network().with_context(
39            || "Dependencies Builder can not get Cardano network while building the chain observer",
40        )?;
41        let sqlite_connection = self.get_sqlite_connection().await?;
42        let open_message_repository = self.get_open_message_repository().await?;
43        let single_signature_repository =
44            Arc::new(SingleSignatureRepository::new(sqlite_connection.clone()));
45        let certificate_repository = self.get_certificate_repository().await?;
46        let certificate_verifier = self.get_certificate_verifier().await?;
47        let genesis_verifier = self.get_genesis_verifier().await?;
48        let multi_signer = self.get_multi_signer().await?;
49        let epoch_service = self.get_epoch_service().await?;
50        let logger = self.root_logger();
51
52        let certifier = Arc::new(MithrilCertifierService::new(
53            cardano_network,
54            open_message_repository,
55            single_signature_repository,
56            certificate_repository,
57            certificate_verifier,
58            genesis_verifier,
59            multi_signer,
60            epoch_service,
61            logger,
62        ));
63
64        Ok(Arc::new(BufferedCertifierService::new(
65            certifier,
66            Arc::new(BufferedSingleSignatureRepository::new(sqlite_connection)),
67            self.root_logger(),
68        )))
69    }
70
71    /// [CertifierService] service
72    pub async fn get_certifier_service(&mut self) -> Result<Arc<dyn CertifierService>> {
73        get_dependency!(self.certifier_service)
74    }
75
76    async fn build_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>> {
77        let multi_signer = MultiSignerImpl::new(
78            self.configuration.aggregate_signature_type(),
79            self.get_epoch_service().await?,
80            self.root_logger(),
81        );
82
83        Ok(Arc::new(multi_signer))
84    }
85
86    /// Get a configured multi signer
87    pub async fn get_multi_signer(&mut self) -> Result<Arc<dyn MultiSigner>> {
88        get_dependency!(self.multi_signer)
89    }
90
91    async fn build_certificate_chain_synchronizer(
92        &mut self,
93    ) -> Result<Arc<dyn CertificateChainSynchronizer>> {
94        let synchronizer: Arc<dyn CertificateChainSynchronizer> =
95            if self.configuration.is_follower_aggregator() {
96                let leader_aggregator_client = self.get_leader_aggregator_client().await?;
97                let verifier = Arc::new(MithrilCertificateVerifier::new(
98                    self.root_logger(),
99                    leader_aggregator_client.clone(),
100                ));
101
102                Arc::new(MithrilCertificateChainSynchronizer::new(
103                    leader_aggregator_client,
104                    self.get_certificate_repository().await?,
105                    verifier,
106                    self.get_genesis_verifier().await?,
107                    self.get_open_message_repository().await?,
108                    self.get_epoch_settings_store().await?,
109                    self.root_logger(),
110                ))
111            } else {
112                Arc::new(MithrilCertificateChainSynchronizerNoop)
113            };
114
115        Ok(synchronizer)
116    }
117
118    /// [CertificateChainSynchronizer] service
119    pub async fn get_certificate_chain_synchronizer(
120        &mut self,
121    ) -> Result<Arc<dyn CertificateChainSynchronizer>> {
122        get_dependency!(self.certificate_chain_synchronizer)
123    }
124
125    async fn build_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
126        let verifier = Arc::new(MithrilCertificateVerifier::new(
127            self.root_logger(),
128            self.get_certificate_repository().await?,
129        ));
130
131        Ok(verifier)
132    }
133
134    /// [CertificateVerifier] service.
135    pub async fn get_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
136        get_dependency!(self.certificate_verifier)
137    }
138
139    async fn build_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
140        let genesis_verifier: ProtocolGenesisVerifier = match self.configuration.environment() {
141            ExecutionEnvironment::Production => ProtocolGenesisVerifier::from_verification_key(
142                ProtocolGenesisVerificationKey::from_json_hex(
143                    &self.configuration.genesis_verification_key(),
144                )
145                .map_err(|e| DependenciesBuilderError::Initialization {
146                    message: format!(
147                        "Could not decode hex key to build genesis verifier: '{}'",
148                        self.configuration.genesis_verification_key()
149                    ),
150                    error: Some(e),
151                })?,
152            ),
153            _ => ProtocolGenesisSigner::create_deterministic_signer().create_verifier(),
154        };
155
156        Ok(Arc::new(genesis_verifier))
157    }
158
159    /// Return a [ProtocolGenesisVerifier]
160    pub async fn get_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
161        get_dependency!(self.genesis_verifier)
162    }
163
164    /// Return a [MithrilSignerRegistrationLeader] service
165    async fn build_mithril_signer_registration_leader(
166        &mut self,
167    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
168        let registerer = MithrilSignerRegistrationLeader::new(
169            self.get_verification_key_store().await?,
170            self.get_signer_store().await?,
171            self.get_signer_registration_verifier().await?,
172        );
173
174        Ok(Arc::new(registerer))
175    }
176
177    /// Return a [MithrilSignerRegistrationLeader]
178    pub async fn get_mithril_signer_registration_leader(
179        &mut self,
180    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
181        get_dependency!(self.mithril_signer_registration_leader)
182    }
183
184    /// Return a [MithrilSignerRegistrationFollower] service
185    async fn build_mithril_signer_registration_follower(
186        &mut self,
187    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
188        let registerer = MithrilSignerRegistrationFollower::new(
189            self.get_epoch_service().await?,
190            self.get_verification_key_store().await?,
191            self.get_signer_store().await?,
192            self.get_signer_registration_verifier().await?,
193            self.get_leader_aggregator_client().await?,
194            self.get_stake_store().await?,
195        );
196
197        Ok(Arc::new(registerer))
198    }
199
200    /// Return a [MithrilSignerRegistrationFollower]
201    pub async fn get_mithril_signer_registration_follower(
202        &mut self,
203    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
204        get_dependency!(self.mithril_signer_registration_follower)
205    }
206
207    /// Return a [SignerRegisterer]
208    pub async fn get_signer_registerer(&mut self) -> Result<Arc<dyn SignerRegisterer>> {
209        get_dependency!(self.signer_registerer = get_mithril_signer_registration!(self))
210    }
211
212    /// Return a [SignerSynchronizer]
213    pub async fn get_signer_synchronizer(&mut self) -> Result<Arc<dyn SignerSynchronizer>> {
214        get_dependency!(self.signer_synchronizer = get_mithril_signer_registration!(self))
215    }
216
217    async fn build_signer_registration_verifier(
218        &mut self,
219    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
220        let registerer = MithrilSignerRegistrationVerifier::new(self.get_chain_observer().await?);
221
222        Ok(Arc::new(registerer))
223    }
224
225    /// Return a [SignerRegistrationVerifier]
226    pub async fn get_signer_registration_verifier(
227        &mut self,
228    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
229        get_dependency!(self.signer_registration_verifier)
230    }
231
232    /// Return a [SignerRegistrationRoundOpener]
233    pub async fn get_signer_registration_round_opener(
234        &mut self,
235    ) -> Result<Arc<dyn SignerRegistrationRoundOpener>> {
236        get_dependency!(
237            self.signer_registration_round_opener = get_mithril_signer_registration!(self)
238        )
239    }
240
241    async fn build_single_signature_authenticator(
242        &mut self,
243    ) -> Result<Arc<SingleSignatureAuthenticator>> {
244        let authenticator =
245            SingleSignatureAuthenticator::new(self.get_multi_signer().await?, self.root_logger());
246
247        Ok(Arc::new(authenticator))
248    }
249
250    /// [SingleSignatureAuthenticator] service
251    pub async fn get_single_signature_authenticator(
252        &mut self,
253    ) -> Result<Arc<SingleSignatureAuthenticator>> {
254        get_dependency!(self.single_signature_authenticator)
255    }
256}
mithril_aggregator/dependency_injection/builder/protocol/certificates.rs

mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs
