WIP: A0-1820: Add justifications and validator implementations

finality-aleph/src/nodes/mod.rs

@@ -3,30 +3,23 @@ mod validator_node;
 
 use std::{future::Future, sync::Arc};
 
-use aleph_primitives::{AuthorityId, SessionAuthorityData};
-use codec::Encode;
-use log::warn;
 pub use nonvalidator_node::run_nonvalidator_node;
 use sc_client_api::Backend;
 use sc_network::NetworkService;
 use sc_network_common::ExHashT;
-use sp_runtime::{
-    traits::{Block, Header, NumberFor},
-    RuntimeAppPublic,
-};
+use sp_runtime::traits::{Block, Header, NumberFor};
 pub use validator_node::run_validator_node;
 
 use crate::{
-    crypto::AuthorityVerifier,
     finalization::AlephFinalizer,
     justification::{
-        AlephJustification, JustificationHandler, JustificationRequestSchedulerImpl, SessionInfo,
-        SessionInfoProvider, Verifier,
+        JustificationHandler, JustificationRequestSchedulerImpl, SessionInfo, SessionInfoProvider,
     },
     last_block_of_session, mpsc,
     mpsc::UnboundedSender,
     session_id_from_block_num,
     session_map::ReadOnlySessionMap,
+    sync::SessionVerifier,
     BlockchainBackend, JustificationNotification, Metrics, MillisecsPerBlock, SessionPeriod,
 };
 
@@ -38,52 +31,6 @@ pub mod testing {
 /// Max amount of tries we can not update a finalized block number before we will clear requests queue
 const MAX_ATTEMPTS: u32 = 5;
 
-struct JustificationVerifier {
-    authority_verifier: AuthorityVerifier,
-    emergency_signer: Option<AuthorityId>,
-}
-
-impl From<SessionAuthorityData> for JustificationVerifier {
-    fn from(authority_data: SessionAuthorityData) -> Self {
-        JustificationVerifier {
-            authority_verifier: AuthorityVerifier::new(authority_data.authorities().to_vec()),
-            emergency_signer: authority_data.emergency_finalizer().clone(),
-        }
-    }
-}
-
-impl<B: Block> Verifier<B> for JustificationVerifier {
-    fn verify(&self, justification: &AlephJustification, hash: B::Hash) -> bool {
-        use AlephJustification::*;
-        let encoded_hash = hash.encode();
-        match justification {
-            CommitteeMultisignature(multisignature) => match self
-                .authority_verifier
-                .is_complete(&encoded_hash, multisignature)
-            {
-                true => true,
-                false => {
-                    warn!(target: "aleph-justification", "Bad multisignature for block hash #{:?} {:?}", hash, multisignature);
-                    false
-                }
-            },
-            EmergencySignature(signature) => match &self.emergency_signer {
-                Some(emergency_signer) => match emergency_signer.verify(&encoded_hash, signature) {
-                    true => true,
-                    false => {
-                        warn!(target: "aleph-justification", "Bad emergency signature for block hash #{:?} {:?}", hash, signature);
-                        false
-                    }
-                },
-                None => {
-                    warn!(target: "aleph-justification", "Received emergency signature for block with hash #{:?}, which has no emergency signer defined.", hash);
-                    false
-                }
-            },
-        }
-    }
-}
-
 struct JustificationParams<B: Block, H: ExHashT, C, BB> {
     pub network: Arc<NetworkService<B, H>>,
     pub client: Arc<C>,
@@ -110,14 +57,13 @@ impl SessionInfoProviderImpl {
 }
 
 #[async_trait::async_trait]
-impl<B: Block> SessionInfoProvider<B, JustificationVerifier> for SessionInfoProviderImpl {
-    async fn for_block_num(&self, number: NumberFor<B>) -> SessionInfo<B, JustificationVerifier> {
+impl<B: Block> SessionInfoProvider<B, SessionVerifier> for SessionInfoProviderImpl {
+    async fn for_block_num(&self, number: NumberFor<B>) -> SessionInfo<B, SessionVerifier> {
         let current_session = session_id_from_block_num::<B>(number, self.session_period);
         let last_block_height = last_block_of_session::<B>(current_session, self.session_period);
         let verifier = self
             .session_authorities
             .get(current_session)
-            .await
             .map(|authority_data| authority_data.into());
 
         SessionInfo {

finality-aleph/src/party/mod.rs

@@ -111,7 +111,6 @@ where
             .session_authorities
             .subscribe_to_insertion(session_id)
             .await
-            .await
         {
             Err(e) => panic!(
                 "Error while receiving the notification about current session {:?}",
@@ -162,8 +161,7 @@ where
         let next_session_id = SessionId(session_id.0 + 1);
         let mut start_next_session_network = Some(
             self.session_authorities
-                .subscribe_to_insertion(next_session_id)
-                .await,
+                .subscribe_to_insertion(next_session_id),
         );
         loop {
             tokio::select! {
@@ -181,7 +179,7 @@ where
                             match notification.await {
                                 Err(e) => {
                                     warn!(target: "aleph-party", "Error with subscription {:?}", e);
-                                    start_next_session_network = Some(self.session_authorities.subscribe_to_insertion(next_session_id).await);
+                                    start_next_session_network = Some(self.session_authorities.subscribe_to_insertion(next_session_id));
                                     None
                                 },
                                 Ok(next_session_authority_data) => {
@@ -424,8 +422,7 @@ mod tests {
             if let Some((session, authorities)) = session_authorities {
                 self.controller
                     .shared_session_map
-                    .update(session, SessionAuthorityData::new(authorities, None))
-                    .await;
+                    .update(session, SessionAuthorityData::new(authorities, None));
             }
 
             if let Some(id) = id {
@@ -486,8 +483,7 @@ mod tests {
             if let Some((session, authorities)) = session_authorities {
                 self.controller
                     .shared_session_map
-                    .update(session, SessionAuthorityData::new(authorities, None))
-                    .await;
+                    .update(session, SessionAuthorityData::new(authorities, None));
             }
 
             if let Some(id) = id {

finality-aleph/src/session.rs

@@ -1,5 +1,5 @@
 use codec::{Decode, Encode};
-use sp_runtime::{traits::Block, SaturatedConversion};
+use sp_runtime::traits::{Block, UniqueSaturatedInto};
 
 use crate::NumberFor;
 
@@ -40,8 +40,15 @@ pub fn last_block_of_session<B: Block>(
     ((session_id.0 + 1) * period.0 - 1).into()
 }
 
+pub fn session_id_from_num<N: UniqueSaturatedInto<u32>>(
+    num: N,
+    period: SessionPeriod,
+) -> SessionId {
+    SessionId(num.unique_saturated_into() / period.0)
+}
+
 pub fn session_id_from_block_num<B: Block>(num: NumberFor<B>, period: SessionPeriod) -> SessionId {
-    SessionId(num.saturated_into::<u32>() / period.0)
+    session_id_from_num(num, period)
 }
 
 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash, Ord, PartialOrd, Encode, Decode)]