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.root_logger(),
109                ))
110            } else {
111                Arc::new(MithrilCertificateChainSynchronizerNoop)
112            };
113
114        Ok(synchronizer)
115    }
116
117    /// [CertificateChainSynchronizer] service
118    pub async fn get_certificate_chain_synchronizer(
119        &mut self,
120    ) -> Result<Arc<dyn CertificateChainSynchronizer>> {
121        get_dependency!(self.certificate_chain_synchronizer)
122    }
123
124    async fn build_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
125        let verifier = Arc::new(MithrilCertificateVerifier::new(
126            self.root_logger(),
127            self.get_certificate_repository().await?,
128        ));
129
130        Ok(verifier)
131    }
132
133    /// [CertificateVerifier] service.
134    pub async fn get_certificate_verifier(&mut self) -> Result<Arc<dyn CertificateVerifier>> {
135        get_dependency!(self.certificate_verifier)
136    }
137
138    async fn build_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
139        let genesis_verifier: ProtocolGenesisVerifier = match self.configuration.environment() {
140            ExecutionEnvironment::Production => ProtocolGenesisVerifier::from_verification_key(
141                ProtocolGenesisVerificationKey::from_json_hex(
142                    &self.configuration.genesis_verification_key(),
143                )
144                .map_err(|e| DependenciesBuilderError::Initialization {
145                    message: format!(
146                        "Could not decode hex key to build genesis verifier: '{}'",
147                        self.configuration.genesis_verification_key()
148                    ),
149                    error: Some(e),
150                })?,
151            ),
152            _ => ProtocolGenesisSigner::create_deterministic_signer().create_verifier(),
153        };
154
155        Ok(Arc::new(genesis_verifier))
156    }
157
158    /// Return a [ProtocolGenesisVerifier]
159    pub async fn get_genesis_verifier(&mut self) -> Result<Arc<ProtocolGenesisVerifier>> {
160        get_dependency!(self.genesis_verifier)
161    }
162
163    /// Return a [MithrilSignerRegistrationLeader] service
164    async fn build_mithril_signer_registration_leader(
165        &mut self,
166    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
167        let registerer = MithrilSignerRegistrationLeader::new(
168            self.get_verification_key_store().await?,
169            self.get_signer_store().await?,
170            self.get_signer_registration_verifier().await?,
171        );
172
173        Ok(Arc::new(registerer))
174    }
175
176    /// Return a [MithrilSignerRegistrationLeader]
177    pub async fn get_mithril_signer_registration_leader(
178        &mut self,
179    ) -> Result<Arc<MithrilSignerRegistrationLeader>> {
180        get_dependency!(self.mithril_signer_registration_leader)
181    }
182
183    /// Return a [MithrilSignerRegistrationFollower] service
184    async fn build_mithril_signer_registration_follower(
185        &mut self,
186    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
187        let registerer = MithrilSignerRegistrationFollower::new(
188            self.get_epoch_service().await?,
189            self.get_verification_key_store().await?,
190            self.get_signer_store().await?,
191            self.get_signer_registration_verifier().await?,
192            self.get_leader_aggregator_client().await?,
193            self.get_stake_store().await?,
194        );
195
196        Ok(Arc::new(registerer))
197    }
198
199    /// Return a [MithrilSignerRegistrationFollower]
200    pub async fn get_mithril_signer_registration_follower(
201        &mut self,
202    ) -> Result<Arc<MithrilSignerRegistrationFollower>> {
203        get_dependency!(self.mithril_signer_registration_follower)
204    }
205
206    /// Return a [SignerRegisterer]
207    pub async fn get_signer_registerer(&mut self) -> Result<Arc<dyn SignerRegisterer>> {
208        get_dependency!(self.signer_registerer = get_mithril_signer_registration!(self))
209    }
210
211    /// Return a [SignerSynchronizer]
212    pub async fn get_signer_synchronizer(&mut self) -> Result<Arc<dyn SignerSynchronizer>> {
213        get_dependency!(self.signer_synchronizer = get_mithril_signer_registration!(self))
214    }
215
216    async fn build_signer_registration_verifier(
217        &mut self,
218    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
219        let registerer = MithrilSignerRegistrationVerifier::new(self.get_chain_observer().await?);
220
221        Ok(Arc::new(registerer))
222    }
223
224    /// Return a [SignerRegistrationVerifier]
225    pub async fn get_signer_registration_verifier(
226        &mut self,
227    ) -> Result<Arc<dyn SignerRegistrationVerifier>> {
228        get_dependency!(self.signer_registration_verifier)
229    }
230
231    /// Return a [SignerRegistrationRoundOpener]
232    pub async fn get_signer_registration_round_opener(
233        &mut self,
234    ) -> Result<Arc<dyn SignerRegistrationRoundOpener>> {
235        get_dependency!(
236            self.signer_registration_round_opener = get_mithril_signer_registration!(self)
237        )
238    }
239
240    async fn build_single_signature_authenticator(
241        &mut self,
242    ) -> Result<Arc<SingleSignatureAuthenticator>> {
243        let authenticator =
244            SingleSignatureAuthenticator::new(self.get_multi_signer().await?, self.root_logger());
245
246        Ok(Arc::new(authenticator))
247    }
248
249    /// [SingleSignatureAuthenticator] service
250    pub async fn get_single_signature_authenticator(
251        &mut self,
252    ) -> Result<Arc<SingleSignatureAuthenticator>> {
253        get_dependency!(self.single_signature_authenticator)
254    }
255}
mithril_aggregator/dependency_injection/builder/protocol/certificates.rs

mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs
