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

mithril_aggregator/dependency_injection/builder/protocol/
certificates.rs
