Add equivocation detector crate and implement clients (#2348) (#2353)

* Split FinalitySyncPipeline and SourceClient

* Move some logic to finality_base

* Add empty equivocation detection clients

* Add equivocation reporting logic to the source client

* Use convenience trait for SubstrateFinalitySyncPipeline

* Define JustificationVerificationContext for GRANDPA

* Equivocation source client: finality_verification_context()

* Equivocation source client: synced_headers_finality_info()

* reuse HeaderFinalityInfo

* Define EquivocationsFinder

* Fix spellcheck

* Address review comments

* Avoid equivocations lookup errors

bridges/relays/finality/src/base.rs

@@ -0,0 +1,51 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+use async_trait::async_trait;
+use bp_header_chain::FinalityProof;
+use futures::Stream;
+use relay_utils::relay_loop::Client as RelayClient;
+use std::fmt::Debug;
+
+/// Base finality pipeline.
+pub trait FinalityPipeline: 'static + Clone + Debug + Send + Sync {
+	/// Name of the finality proofs source.
+	const SOURCE_NAME: &'static str;
+	/// Name of the finality proofs target.
+	const TARGET_NAME: &'static str;
+
+	/// Synced headers are identified by this hash.
+	type Hash: Eq + Clone + Copy + Send + Sync + Debug;
+	/// Synced headers are identified by this number.
+	type Number: relay_utils::BlockNumberBase;
+	/// Finality proof type.
+	type FinalityProof: FinalityProof<Self::Number>;
+}
+
+/// Source client used in finality related loops.
+#[async_trait]
+pub trait SourceClientBase<P: FinalityPipeline>: RelayClient {
+	/// Stream of new finality proofs. The stream is allowed to miss proofs for some
+	/// headers, even if those headers are mandatory.
+	type FinalityProofsStream: Stream<Item = P::FinalityProof> + Send + Unpin;
+
+	/// Subscribe to new finality proofs.
+	async fn finality_proofs(&self) -> Result<Self::FinalityProofsStream, Self::Error>;
+}
+
+/// Target client used in finality related loops.
+#[async_trait]
+pub trait TargetClientBase<P: FinalityPipeline>: RelayClient {}

bridges/relays/finality/src/finality_loop.rs

@@ -20,11 +20,13 @@
 //! assume that the persistent proof either exists, or will eventually become available.
 
 use crate::{
-	sync_loop_metrics::SyncLoopMetrics, FinalityProof, FinalitySyncPipeline, SourceHeader,
+	sync_loop_metrics::SyncLoopMetrics, FinalityPipeline, FinalitySyncPipeline, SourceClientBase,
+	SourceHeader,
 };
 
 use async_trait::async_trait;
 use backoff::backoff::Backoff;
+use bp_header_chain::FinalityProof;
 use futures::{select, Future, FutureExt, Stream, StreamExt};
 use num_traits::{One, Saturating};
 use relay_utils::{
@@ -66,11 +68,7 @@ pub struct FinalitySyncParams {
 
 /// Source client used in finality synchronization loop.
 #[async_trait]
-pub trait SourceClient<P: FinalitySyncPipeline>: RelayClient {
-	/// Stream of new finality proofs. The stream is allowed to miss proofs for some
-	/// headers, even if those headers are mandatory.
-	type FinalityProofsStream: Stream<Item = P::FinalityProof> + Send;
-
+pub trait SourceClient<P: FinalitySyncPipeline>: SourceClientBase<P> {
 	/// Get best finalized block number.
 	async fn best_finalized_block_number(&self) -> Result<P::Number, Self::Error>;
 
@@ -79,9 +77,6 @@ pub trait SourceClient<P: FinalitySyncPipeline>: RelayClient {
 		&self,
 		number: P::Number,
 	) -> Result<(P::Header, Option<P::FinalityProof>), Self::Error>;
-
-	/// Subscribe to new finality proofs.
-	async fn finality_proofs(&self) -> Result<Self::FinalityProofsStream, Self::Error>;
 }
 
 /// Target client used in finality synchronization loop.
@@ -143,10 +138,10 @@ pub async fn run<P: FinalitySyncPipeline>(
 pub(crate) type UnjustifiedHeaders<H> = Vec<H>;
 /// Finality proofs container. Ordered by target header number.
 pub(crate) type FinalityProofs<P> =
-	Vec<(<P as FinalitySyncPipeline>::Number, <P as FinalitySyncPipeline>::FinalityProof)>;
+	Vec<(<P as FinalityPipeline>::Number, <P as FinalityPipeline>::FinalityProof)>;
 /// Reference to finality proofs container.
 pub(crate) type FinalityProofsRef<'a, P> =
-	&'a [(<P as FinalitySyncPipeline>::Number, <P as FinalitySyncPipeline>::FinalityProof)];
+	&'a [(<P as FinalityPipeline>::Number, <P as FinalityPipeline>::FinalityProof)];
 
 /// Error that may happen inside finality synchronization loop.
 #[derive(Debug)]

bridges/relays/finality/src/finality_loop_tests.rs

@@ -26,11 +26,11 @@ use crate::{
 		SourceClient, TargetClient,
 	},
 	sync_loop_metrics::SyncLoopMetrics,
-	FinalityProof, FinalitySyncPipeline, SourceHeader,
+	FinalityPipeline, FinalitySyncPipeline, SourceClientBase, SourceHeader,
 };
 
 use async_trait::async_trait;
-use bp_header_chain::GrandpaConsensusLogReader;
+use bp_header_chain::{FinalityProof, GrandpaConsensusLogReader};
 use futures::{FutureExt, Stream, StreamExt};
 use parking_lot::Mutex;
 use relay_utils::{
@@ -80,15 +80,18 @@ impl MaybeConnectionError for TestError {
 #[derive(Debug, Clone)]
 struct TestFinalitySyncPipeline;
 
-impl FinalitySyncPipeline for TestFinalitySyncPipeline {
+impl FinalityPipeline for TestFinalitySyncPipeline {
 	const SOURCE_NAME: &'static str = "TestSource";
 	const TARGET_NAME: &'static str = "TestTarget";
 
 	type Hash = TestHash;
 	type Number = TestNumber;
+	type FinalityProof = TestFinalityProof;
+}
+
+impl FinalitySyncPipeline for TestFinalitySyncPipeline {
 	type ConsensusLogReader = GrandpaConsensusLogReader<TestNumber>;
 	type Header = TestSourceHeader;
-	type FinalityProof = TestFinalityProof;
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -146,9 +149,18 @@ impl RelayClient for TestSourceClient {
 }
 
 #[async_trait]
-impl SourceClient<TestFinalitySyncPipeline> for TestSourceClient {
+impl SourceClientBase<TestFinalitySyncPipeline> for TestSourceClient {
 	type FinalityProofsStream = Pin<Box<dyn Stream<Item = TestFinalityProof> + 'static + Send>>;
 
+	async fn finality_proofs(&self) -> Result<Self::FinalityProofsStream, TestError> {
+		let mut data = self.data.lock();
+		(self.on_method_call)(&mut data);
+		Ok(futures::stream::iter(data.source_proofs.clone()).boxed())
+	}
+}
+
+#[async_trait]
+impl SourceClient<TestFinalitySyncPipeline> for TestSourceClient {
 	async fn best_finalized_block_number(&self) -> Result<TestNumber, TestError> {
 		let mut data = self.data.lock();
 		(self.on_method_call)(&mut data);
@@ -163,12 +175,6 @@ impl SourceClient<TestFinalitySyncPipeline> for TestSourceClient {
 		(self.on_method_call)(&mut data);
 		data.source_headers.get(&number).cloned().ok_or(TestError::NonConnection)
 	}
-
-	async fn finality_proofs(&self) -> Result<Self::FinalityProofsStream, TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(&mut data);
-		Ok(futures::stream::iter(data.source_proofs.clone()).boxed())
-	}
 }
 
 #[derive(Clone)]

bridges/relays/finality/src/lib.rs

@@ -20,34 +20,25 @@
 //! to submit all source headers to the target node.
 
 pub use crate::{
+	base::{FinalityPipeline, SourceClientBase},
 	finality_loop::{metrics_prefix, run, FinalitySyncParams, SourceClient, TargetClient},
 	sync_loop_metrics::SyncLoopMetrics,
 };
 
-use bp_header_chain::{ConsensusLogReader, FinalityProof};
+use bp_header_chain::ConsensusLogReader;
 use std::fmt::Debug;
 
+mod base;
 mod finality_loop;
 mod finality_loop_tests;
 mod sync_loop_metrics;
 
 /// Finality proofs synchronization pipeline.
-pub trait FinalitySyncPipeline: 'static + Clone + Debug + Send + Sync {
-	/// Name of the finality proofs source.
-	const SOURCE_NAME: &'static str;
-	/// Name of the finality proofs target.
-	const TARGET_NAME: &'static str;
-
-	/// Headers we're syncing are identified by this hash.
-	type Hash: Eq + Clone + Copy + Send + Sync + Debug;
-	/// Headers we're syncing are identified by this number.
-	type Number: relay_utils::BlockNumberBase;
+pub trait FinalitySyncPipeline: FinalityPipeline {
 	/// A reader that can extract the consensus log from the header digest and interpret it.
 	type ConsensusLogReader: ConsensusLogReader;
 	/// Type of header that we're syncing.
 	type Header: SourceHeader<Self::Hash, Self::Number, Self::ConsensusLogReader>;
-	/// Finality proof type.
-	type FinalityProof: FinalityProof<Self::Number>;
 }
 
 /// Header that we're receiving from source node.