Define SubstrateBeefy RPC client

relays/client-substrate/src/client.rs

@@ -19,8 +19,8 @@
 use crate::{
 	chain::{Chain, ChainWithBalances},
 	rpc::{
-		SubstrateAuthorClient, SubstrateChainClient, SubstrateFrameSystemClient,
-		SubstrateGrandpaClient, SubstrateStateClient, SubstrateSystemClient,
+		SubstrateAuthorClient, SubstrateChainClient, SubstrateFinalityClient,
+		SubstrateFrameSystemClient, SubstrateStateClient, SubstrateSystemClient,
 		SubstrateTransactionPaymentClient,
 	},
 	transaction_stall_timeout, ConnectionParams, Error, HashOf, HeaderIdOf, Result, SignParam,
@@ -642,11 +642,13 @@ impl<C: Chain> Client<C> {
 		.await
 	}
 
-	/// Return new GRANDPA justifications stream.
-	pub async fn subscribe_grandpa_justifications(&self) -> Result<Subscription<Bytes>> {
+	/// Return new finality justifications stream.
+	pub async fn subscribe_finality_justifications<FC: SubstrateFinalityClient<C>>(
+		&self,
+	) -> Result<Subscription<Bytes>> {
 		let subscription = self
 			.jsonrpsee_execute(move |client| async move {
-				Ok(SubstrateGrandpaClient::<C>::subscribe_justifications(&*client).await?)
+				Ok(FC::subscribe_justifications(&client).await?)
 			})
 			.await?;
 		let (sender, receiver) = futures::channel::mpsc::channel(MAX_SUBSCRIPTION_CAPACITY);

relays/client-substrate/src/lib.rs

@@ -39,6 +39,7 @@ pub use crate::{
 	},
 	client::{ChainRuntimeVersion, Client, OpaqueGrandpaAuthoritiesSet, Subscription},
 	error::{Error, Result},
+	rpc::{SubstrateBeefyFinalityClient, SubstrateFinalityClient, SubstrateGrandpaFinalityClient},
 	sync_header::SyncHeader,
 	transaction_tracker::TransactionTracker,
 };

relays/client-substrate/src/rpc.rs

@@ -16,9 +16,15 @@
 
 //! The most generic Substrate node RPC interface.
 
-use crate::{Chain, TransactionStatusOf};
+use async_trait::async_trait;
 
-use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use crate::{Chain, ChainWithGrandpa, TransactionStatusOf};
+
+use jsonrpsee::{
+	core::{client::Subscription, RpcResult},
+	proc_macros::rpc,
+	ws_client::WsClient,
+};
 use pallet_transaction_payment_rpc_runtime_api::FeeDetails;
 use sc_rpc_api::{state::ReadProof, system::Health};
 use sp_core::{
@@ -100,14 +106,49 @@ pub(crate) trait SubstrateState<C> {
 	) -> RpcResult<ReadProof<C::Hash>>;
 }
 
+/// RPC methods that we are using for a certain finality gadget.
+#[async_trait]
+pub trait SubstrateFinalityClient<C: Chain> {
+	/// Subscribe to finality justifications.
+	async fn subscribe_justifications(client: &WsClient) -> RpcResult<Subscription<Bytes>>;
+}
+
 /// RPC methods of Substrate `grandpa` namespace, that we are using.
-#[rpc(client, client_bounds(C: Chain), namespace = "grandpa")]
+#[rpc(client, client_bounds(C: ChainWithGrandpa), namespace = "grandpa")]
 pub(crate) trait SubstrateGrandpa<C> {
 	/// Subscribe to GRANDPA justifications.
 	#[subscription(name = "subscribeJustifications", unsubscribe = "unsubscribeJustifications", item = Bytes)]
 	fn subscribe_justifications(&self);
 }
 
+/// RPC finality methods of Substrate `grandpa` namespace, that we are using.
+pub struct SubstrateGrandpaFinalityClient;
+#[async_trait]
+impl<C: ChainWithGrandpa> SubstrateFinalityClient<C> for SubstrateGrandpaFinalityClient {
+	async fn subscribe_justifications(client: &WsClient) -> RpcResult<Subscription<Bytes>> {
+		SubstrateGrandpaClient::<C>::subscribe_justifications(client).await
+	}
+}
+
+// TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged
+/// RPC methods of Substrate `beefy` namespace, that we are using.
+#[rpc(client, client_bounds(C: Chain), namespace = "beefy")]
+pub(crate) trait SubstrateBeefy<C> {
+	/// Subscribe to BEEFY justifications.
+	#[subscription(name = "subscribeJustifications", unsubscribe = "unsubscribeJustifications", item = Bytes)]
+	fn subscribe_justifications(&self);
+}
+
+/// RPC finality methods of Substrate `beefy` namespace, that we are using.
+pub struct SubstrateBeefyFinalityClient;
+// TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged
+#[async_trait]
+impl<C: Chain> SubstrateFinalityClient<C> for SubstrateBeefyFinalityClient {
+	async fn subscribe_justifications(client: &WsClient) -> RpcResult<Subscription<Bytes>> {
+		SubstrateBeefyClient::<C>::subscribe_justifications(client).await
+	}
+}
+
 /// RPC methods of Substrate `system` frame pallet, that we are using.
 #[rpc(client, client_bounds(C: Chain), namespace = "system")]
 pub(crate) trait SubstrateFrameSystem<C> {

relays/lib-substrate-relay/src/finality/engine.rs

@@ -29,18 +29,20 @@ use finality_grandpa::voter_set::VoterSet;
 use num_traits::{One, Zero};
 use relay_substrate_client::{
 	BlockNumberOf, Chain, ChainWithGrandpa, Client, Error as SubstrateError, HashOf, HeaderOf,
-	Subscription,
+	Subscription, SubstrateFinalityClient, SubstrateGrandpaFinalityClient,
 };
 use sp_core::{storage::StorageKey, Bytes};
 use sp_finality_grandpa::AuthorityList as GrandpaAuthoritiesSet;
 use sp_runtime::{traits::Header, ConsensusEngineId};
 use std::marker::PhantomData;
 
-/// Finality enfine, used by the Substrate chain.
+/// Finality engine, used by the Substrate chain.
 #[async_trait]
 pub trait Engine<C: Chain>: Send {
 	/// Unique consensus engine identifier.
 	const ID: ConsensusEngineId;
+	/// Type of Finality RPC client used by this engine.
+	type FinalityClient: SubstrateFinalityClient<C>;
 	/// Type of finality proofs, used by consensus engine.
 	type FinalityProof: FinalityProof<BlockNumberOf<C>> + Decode + Encode;
 	/// Type of bridge pallet initialization data.
@@ -57,7 +59,9 @@ pub trait Engine<C: Chain>: Send {
 	/// Note that we don't care about type of the value - just if it present or not.
 	fn is_initialized_key() -> StorageKey;
 	/// A method to subscribe to encoded finality proofs, given source client.
-	async fn finality_proofs(client: Client<C>) -> Result<Subscription<Bytes>, SubstrateError>;
+	async fn finality_proofs(client: &Client<C>) -> Result<Subscription<Bytes>, SubstrateError> {
+		client.subscribe_finality_justifications::<Self::FinalityClient>().await
+	}
 	/// Prepare initialization data for the finality bridge pallet.
 	async fn prepare_initialization_data(
 		client: Client<C>,
@@ -117,6 +121,7 @@ impl<C: ChainWithGrandpa> Grandpa<C> {
 #[async_trait]
 impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 	const ID: ConsensusEngineId = sp_finality_grandpa::GRANDPA_ENGINE_ID;
+	type FinalityClient = SubstrateGrandpaFinalityClient;
 	type FinalityProof = GrandpaJustification<HeaderOf<C>>;
 	type InitializationData = bp_header_chain::InitializationData<C::Header>;
 	type OperatingMode = BasicOperatingMode;
@@ -129,10 +134,6 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 		bp_header_chain::storage_keys::best_finalized_key(C::WITH_CHAIN_GRANDPA_PALLET_NAME)
 	}
 
-	async fn finality_proofs(client: Client<C>) -> Result<Subscription<Bytes>, SubstrateError> {
-		client.subscribe_grandpa_justifications().await
-	}
-
 	/// Prepare initialization data for the GRANDPA verifier pallet.
 	async fn prepare_initialization_data(
 		source_client: Client<C>,
@@ -144,8 +145,7 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 		// But now there are problems with this approach - `CurrentSetId` may return invalid value.
 		// So here we're waiting for the next justification, read the authorities set and then try
 		// to figure out the set id with bruteforce.
-		let justifications = source_client
-			.subscribe_grandpa_justifications()
+		let justifications = Self::finality_proofs(&source_client)
 			.await
 			.map_err(|err| Error::Subscribe(C::NAME, err))?;
 		// Read next justification - the header that it finalizes will be used as initial header.

relays/lib-substrate-relay/src/finality/source.rs

@@ -142,7 +142,7 @@ impl<P: SubstrateFinalitySyncPipeline> SourceClient<FinalitySyncPipelineAdapter<
 
 	async fn finality_proofs(&self) -> Result<Self::FinalityProofsStream, Error> {
 		Ok(unfold(
-			P::FinalityEngine::finality_proofs(self.client.clone()).await?,
+			P::FinalityEngine::finality_proofs(&self.client).await?,
 			move |subscription| async move {
 				loop {
 					let log_error = |err| {