Introduce interface for relay chain interaction (#835)

cumulus/client/consensus/aura/Cargo.toml

@@ -24,9 +24,6 @@ sc-telemetry = { git = "https://github.com/paritytech/substrate", branch = "mast
 sc-consensus = { git = "https://github.com/paritytech/substrate", branch = "master" }
 substrate-prometheus-endpoint = { git = "https://github.com/paritytech/substrate", branch = "master" }
 
-# Polkadot dependencies
-polkadot-client = { git = "https://github.com/paritytech/polkadot", branch = "master" }
-
 # Cumulus dependencies
 cumulus-client-consensus-common = { path = "../common" }
 cumulus-primitives-core = { path = "../../../primitives/core" }

cumulus/client/consensus/aura/src/lib.rs

@@ -26,13 +26,10 @@ use codec::{Decode, Encode};
 use cumulus_client_consensus_common::{
 	ParachainBlockImport, ParachainCandidate, ParachainConsensus,
 };
-use cumulus_primitives_core::{
-	relay_chain::v1::{Block as PBlock, Hash as PHash, ParachainHost},
-	PersistedValidationData,
-};
+use cumulus_primitives_core::{relay_chain::v1::Hash as PHash, PersistedValidationData};
+
 use futures::lock::Mutex;
-use polkadot_client::ClientHandle;
-use sc_client_api::{backend::AuxStore, Backend, BlockOf};
+use sc_client_api::{backend::AuxStore, BlockOf};
 use sc_consensus::BlockImport;
 use sc_consensus_slots::{BackoffAuthoringBlocksStrategy, SlotInfo};
 use sc_telemetry::TelemetryHandle;
@@ -46,8 +43,8 @@ use sp_consensus_aura::AuraApi;
 use sp_core::crypto::Pair;
 use sp_inherents::{CreateInherentDataProviders, InherentData, InherentDataProvider};
 use sp_keystore::SyncCryptoStorePtr;
-use sp_runtime::traits::{Block as BlockT, HashFor, Header as HeaderT, Member, NumberFor};
-use std::{convert::TryFrom, hash::Hash, marker::PhantomData, sync::Arc};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member, NumberFor};
+use std::{convert::TryFrom, hash::Hash, sync::Arc};
 
 mod import_queue;
 
@@ -60,10 +57,8 @@ pub use sc_consensus_slots::InherentDataProviderExt;
 const LOG_TARGET: &str = "aura::cumulus";
 
 /// The implementation of the AURA consensus for parachains.
-pub struct AuraConsensus<B, RClient, RBackend, CIDP> {
+pub struct AuraConsensus<B, CIDP> {
 	create_inherent_data_providers: Arc<CIDP>,
-	relay_chain_client: Arc<RClient>,
-	relay_chain_backend: Arc<RBackend>,
 	aura_worker: Arc<
 		Mutex<
 			dyn sc_consensus_slots::SlotWorker<B, <EnableProofRecording as ProofRecording>::Proof>
@@ -74,44 +69,39 @@ pub struct AuraConsensus<B, RClient, RBackend, CIDP> {
 	slot_duration: SlotDuration,
 }
 
-impl<B, RClient, RBackend, CIDP> Clone for AuraConsensus<B, RClient, RBackend, CIDP> {
+impl<B, CIDP> Clone for AuraConsensus<B, CIDP> {
 	fn clone(&self) -> Self {
 		Self {
 			create_inherent_data_providers: self.create_inherent_data_providers.clone(),
-			relay_chain_backend: self.relay_chain_backend.clone(),
-			relay_chain_client: self.relay_chain_client.clone(),
 			aura_worker: self.aura_worker.clone(),
 			slot_duration: self.slot_duration,
 		}
 	}
 }
 
-impl<B, RClient, RBackend, CIDP> AuraConsensus<B, RClient, RBackend, CIDP>
+impl<B, CIDP> AuraConsensus<B, CIDP>
 where
 	B: BlockT,
-	RClient: ProvideRuntimeApi<PBlock>,
-	RClient::Api: ParachainHost<PBlock>,
-	RBackend: Backend<PBlock>,
-	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)>,
+	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + 'static,
 	CIDP::InherentDataProviders: InherentDataProviderExt,
 {
-	/// Create a new instance of AURA consensus.
-	pub fn new<P, Client, BI, SO, PF, BS, Error>(
-		para_client: Arc<Client>,
-		block_import: BI,
-		sync_oracle: SO,
-		proposer_factory: PF,
-		force_authoring: bool,
-		backoff_authoring_blocks: Option<BS>,
-		keystore: SyncCryptoStorePtr,
-		create_inherent_data_providers: CIDP,
-		polkadot_client: Arc<RClient>,
-		polkadot_backend: Arc<RBackend>,
-		slot_duration: SlotDuration,
-		telemetry: Option<TelemetryHandle>,
-		block_proposal_slot_portion: SlotProportion,
-		max_block_proposal_slot_portion: Option<SlotProportion>,
-	) -> Self
+	/// Create a new boxed instance of AURA consensus.
+	pub fn build<P, Client, BI, SO, PF, BS, Error>(
+		BuildAuraConsensusParams {
+			proposer_factory,
+			create_inherent_data_providers,
+			block_import,
+			para_client,
+			backoff_authoring_blocks,
+			sync_oracle,
+			keystore,
+			force_authoring,
+			slot_duration,
+			telemetry,
+			block_proposal_slot_portion,
+			max_block_proposal_slot_portion,
+		}: BuildAuraConsensusParams<PF, BI, CIDP, Client, BS, SO>,
+	) -> Box<dyn ParachainConsensus<B>>
 	where
 		Client:
 			ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync + 'static,
@@ -148,13 +138,11 @@ where
 			},
 		);
 
-		Self {
+		Box::new(Self {
 			create_inherent_data_providers: Arc::new(create_inherent_data_providers),
-			relay_chain_backend: polkadot_backend,
-			relay_chain_client: polkadot_client,
 			aura_worker: Arc::new(Mutex::new(worker)),
 			slot_duration,
-		}
+		})
 	}
 
 	/// Create the inherent data.
@@ -194,13 +182,10 @@ where
 }
 
 #[async_trait::async_trait]
-impl<B, RClient, RBackend, CIDP> ParachainConsensus<B> for AuraConsensus<B, RClient, RBackend, CIDP>
+impl<B, CIDP> ParachainConsensus<B> for AuraConsensus<B, CIDP>
 where
 	B: BlockT,
-	RClient: ProvideRuntimeApi<PBlock> + Send + Sync,
-	RClient::Api: ParachainHost<PBlock>,
-	RBackend: Backend<PBlock>,
-	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + Send + Sync,
+	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + Send + Sync + 'static,
 	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
 {
 	async fn produce_candidate(
@@ -232,12 +217,10 @@ where
 }
 
 /// Paramaters of [`build_aura_consensus`].
-pub struct BuildAuraConsensusParams<PF, BI, RBackend, CIDP, Client, BS, SO> {
+pub struct BuildAuraConsensusParams<PF, BI, CIDP, Client, BS, SO> {
 	pub proposer_factory: PF,
 	pub create_inherent_data_providers: CIDP,
 	pub block_import: BI,
-	pub relay_chain_client: polkadot_client::Client,
-	pub relay_chain_backend: Arc<RBackend>,
 	pub para_client: Arc<Client>,
 	pub backoff_authoring_blocks: Option<BS>,
 	pub sync_oracle: SO,
@@ -248,247 +231,3 @@ pub struct BuildAuraConsensusParams<PF, BI, RBackend, CIDP, Client, BS, SO> {
 	pub block_proposal_slot_portion: SlotProportion,
 	pub max_block_proposal_slot_portion: Option<SlotProportion>,
 }
-
-/// Build the [`AuraConsensus`].
-///
-/// Returns a boxed [`ParachainConsensus`].
-pub fn build_aura_consensus<P, Block, PF, BI, RBackend, CIDP, Client, SO, BS, Error>(
-	BuildAuraConsensusParams {
-		proposer_factory,
-		create_inherent_data_providers,
-		block_import,
-		relay_chain_client,
-		relay_chain_backend,
-		para_client,
-		backoff_authoring_blocks,
-		sync_oracle,
-		keystore,
-		force_authoring,
-		slot_duration,
-		telemetry,
-		block_proposal_slot_portion,
-		max_block_proposal_slot_portion,
-	}: BuildAuraConsensusParams<PF, BI, RBackend, CIDP, Client, BS, SO>,
-) -> Box<dyn ParachainConsensus<Block>>
-where
-	Block: BlockT,
-	RBackend: Backend<PBlock> + 'static,
-	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)>
-		+ Send
-		+ Sync
-		+ 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
-	Client: ProvideRuntimeApi<Block>
-		+ BlockOf
-		+ AuxStore
-		+ HeaderBackend<Block>
-		+ Send
-		+ Sync
-		+ 'static,
-	Client::Api: AuraApi<Block, P::Public>,
-	BI: BlockImport<Block, Transaction = sp_api::TransactionFor<Client, Block>>
-		+ Send
-		+ Sync
-		+ 'static,
-	SO: SyncOracle + Send + Sync + Clone + 'static,
-	BS: BackoffAuthoringBlocksStrategy<NumberFor<Block>> + Send + Sync + 'static,
-	PF: Environment<Block, Error = Error> + Send + Sync + 'static,
-	PF::Proposer: Proposer<
-		Block,
-		Error = Error,
-		Transaction = sp_api::TransactionFor<Client, Block>,
-		ProofRecording = EnableProofRecording,
-		Proof = <EnableProofRecording as ProofRecording>::Proof,
-	>,
-	Error: std::error::Error + Send + From<sp_consensus::Error> + 'static,
-	P: Pair + Send + Sync,
-	P::Public: AppPublic + Hash + Member + Encode + Decode,
-	P::Signature: TryFrom<Vec<u8>> + Hash + Member + Encode + Decode,
-{
-	AuraConsensusBuilder::<P, _, _, _, _, _, _, _, _, _>::new(
-		proposer_factory,
-		block_import,
-		create_inherent_data_providers,
-		relay_chain_client,
-		relay_chain_backend,
-		para_client,
-		backoff_authoring_blocks,
-		sync_oracle,
-		force_authoring,
-		keystore,
-		slot_duration,
-		telemetry,
-		block_proposal_slot_portion,
-		max_block_proposal_slot_portion,
-	)
-	.build()
-}
-
-/// Aura consensus builder.
-///
-/// Builds a [`AuraConsensus`] for a parachain. As this requires
-/// a concrete relay chain client instance, the builder takes a [`polkadot_client::Client`]
-/// that wraps this concrete instance. By using [`polkadot_client::ExecuteWithClient`]
-/// the builder gets access to this concrete instance.
-struct AuraConsensusBuilder<P, Block, PF, BI, RBackend, CIDP, Client, SO, BS, Error> {
-	_phantom: PhantomData<(Block, Error, P)>,
-	proposer_factory: PF,
-	create_inherent_data_providers: CIDP,
-	block_import: BI,
-	relay_chain_backend: Arc<RBackend>,
-	relay_chain_client: polkadot_client::Client,
-	para_client: Arc<Client>,
-	backoff_authoring_blocks: Option<BS>,
-	sync_oracle: SO,
-	force_authoring: bool,
-	keystore: SyncCryptoStorePtr,
-	slot_duration: SlotDuration,
-	telemetry: Option<TelemetryHandle>,
-	block_proposal_slot_portion: SlotProportion,
-	max_block_proposal_slot_portion: Option<SlotProportion>,
-}
-
-impl<Block, PF, BI, RBackend, CIDP, Client, SO, BS, P, Error>
-	AuraConsensusBuilder<P, Block, PF, BI, RBackend, CIDP, Client, SO, BS, Error>
-where
-	Block: BlockT,
-	RBackend: Backend<PBlock> + 'static,
-	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)>
-		+ Send
-		+ Sync
-		+ 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
-	Client: ProvideRuntimeApi<Block>
-		+ BlockOf
-		+ AuxStore
-		+ HeaderBackend<Block>
-		+ Send
-		+ Sync
-		+ 'static,
-	Client::Api: AuraApi<Block, P::Public>,
-	BI: BlockImport<Block, Transaction = sp_api::TransactionFor<Client, Block>>
-		+ Send
-		+ Sync
-		+ 'static,
-	SO: SyncOracle + Send + Sync + Clone + 'static,
-	BS: BackoffAuthoringBlocksStrategy<NumberFor<Block>> + Send + Sync + 'static,
-	PF: Environment<Block, Error = Error> + Send + Sync + 'static,
-	PF::Proposer: Proposer<
-		Block,
-		Error = Error,
-		Transaction = sp_api::TransactionFor<Client, Block>,
-		ProofRecording = EnableProofRecording,
-		Proof = <EnableProofRecording as ProofRecording>::Proof,
-	>,
-	Error: std::error::Error + Send + From<sp_consensus::Error> + 'static,
-	P: Pair + Send + Sync,
-	P::Public: AppPublic + Hash + Member + Encode + Decode,
-	P::Signature: TryFrom<Vec<u8>> + Hash + Member + Encode + Decode,
-{
-	/// Create a new instance of the builder.
-	fn new(
-		proposer_factory: PF,
-		block_import: BI,
-		create_inherent_data_providers: CIDP,
-		relay_chain_client: polkadot_client::Client,
-		relay_chain_backend: Arc<RBackend>,
-		para_client: Arc<Client>,
-		backoff_authoring_blocks: Option<BS>,
-		sync_oracle: SO,
-		force_authoring: bool,
-		keystore: SyncCryptoStorePtr,
-		slot_duration: SlotDuration,
-		telemetry: Option<TelemetryHandle>,
-		block_proposal_slot_portion: SlotProportion,
-		max_block_proposal_slot_portion: Option<SlotProportion>,
-	) -> Self {
-		Self {
-			_phantom: PhantomData,
-			proposer_factory,
-			block_import,
-			create_inherent_data_providers,
-			relay_chain_backend,
-			relay_chain_client,
-			para_client,
-			backoff_authoring_blocks,
-			sync_oracle,
-			force_authoring,
-			keystore,
-			slot_duration,
-			telemetry,
-			block_proposal_slot_portion,
-			max_block_proposal_slot_portion,
-		}
-	}
-
-	/// Build the relay chain consensus.
-	fn build(self) -> Box<dyn ParachainConsensus<Block>> {
-		self.relay_chain_client.clone().execute_with(self)
-	}
-}
-
-impl<Block, PF, BI, RBackend, CIDP, Client, SO, BS, P, Error> polkadot_client::ExecuteWithClient
-	for AuraConsensusBuilder<P, Block, PF, BI, RBackend, CIDP, Client, SO, BS, Error>
-where
-	Block: BlockT,
-	RBackend: Backend<PBlock> + 'static,
-	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)>
-		+ Send
-		+ Sync
-		+ 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
-	Client: ProvideRuntimeApi<Block>
-		+ BlockOf
-		+ AuxStore
-		+ HeaderBackend<Block>
-		+ Send
-		+ Sync
-		+ 'static,
-	Client::Api: AuraApi<Block, P::Public>,
-	BI: BlockImport<Block, Transaction = sp_api::TransactionFor<Client, Block>>
-		+ Send
-		+ Sync
-		+ 'static,
-	SO: SyncOracle + Send + Sync + Clone + 'static,
-	BS: BackoffAuthoringBlocksStrategy<NumberFor<Block>> + Send + Sync + 'static,
-	PF: Environment<Block, Error = Error> + Send + Sync + 'static,
-	PF::Proposer: Proposer<
-		Block,
-		Error = Error,
-		Transaction = sp_api::TransactionFor<Client, Block>,
-		ProofRecording = EnableProofRecording,
-		Proof = <EnableProofRecording as ProofRecording>::Proof,
-	>,
-	Error: std::error::Error + Send + From<sp_consensus::Error> + 'static,
-	P: Pair + Send + Sync,
-	P::Public: AppPublic + Hash + Member + Encode + Decode,
-	P::Signature: TryFrom<Vec<u8>> + Hash + Member + Encode + Decode,
-{
-	type Output = Box<dyn ParachainConsensus<Block>>;
-
-	fn execute_with_client<PClient, Api, PBackend>(self, client: Arc<PClient>) -> Self::Output
-	where
-		<Api as sp_api::ApiExt<PBlock>>::StateBackend: sp_api::StateBackend<HashFor<PBlock>>,
-		PBackend: Backend<PBlock>,
-		PBackend::State: sp_api::StateBackend<sp_runtime::traits::BlakeTwo256>,
-		Api: polkadot_client::RuntimeApiCollection<StateBackend = PBackend::State>,
-		PClient: polkadot_client::AbstractClient<PBlock, PBackend, Api = Api> + 'static,
-	{
-		Box::new(AuraConsensus::new::<P, _, _, _, _, _, _>(
-			self.para_client,
-			self.block_import,
-			self.sync_oracle,
-			self.proposer_factory,
-			self.force_authoring,
-			self.backoff_authoring_blocks,
-			self.keystore,
-			self.create_inherent_data_providers,
-			client.clone(),
-			self.relay_chain_backend,
-			self.slot_duration,
-			self.telemetry,
-			self.block_proposal_slot_portion,
-			self.max_block_proposal_slot_portion,
-		))
-	}
-}

cumulus/client/consensus/common/Cargo.toml

@@ -18,6 +18,9 @@ sp-trie = { git = "https://github.com/paritytech/substrate", branch = "master" }
 # Polkadot deps
 polkadot-primitives = { git = "https://github.com/paritytech/polkadot", branch = "master" }
 
+# Cumulus deps
+cumulus-relay-chain-interface = { path = "../../relay-chain-interface" }
+
 # Other deps
 futures = { version = "0.3.8", features = ["compat"] }
 codec = { package = "parity-scale-codec", version = "2.3.0", features = [ "derive" ] }

cumulus/client/consensus/common/src/parachain_consensus.rs

@@ -14,11 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
+use cumulus_relay_chain_interface::RelayChainInterface;
 use sc_client_api::{
 	Backend, BlockBackend, BlockImportNotification, BlockchainEvents, Finalizer, UsageProvider,
 };
 use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
-use sp_api::ProvideRuntimeApi;
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
 use sp_consensus::{BlockOrigin, BlockStatus};
 use sp_runtime::{
@@ -26,9 +26,7 @@ use sp_runtime::{
 	traits::{Block as BlockT, Header as HeaderT},
 };
 
-use polkadot_primitives::v1::{
-	Block as PBlock, Id as ParaId, OccupiedCoreAssumption, ParachainHost,
-};
+use polkadot_primitives::v1::{Block as PBlock, Id as ParaId, OccupiedCoreAssumption};
 
 use codec::Decode;
 use futures::{future, select, FutureExt, Stream, StreamExt};
@@ -370,10 +368,9 @@ where
 	}
 }
 
-impl<T> RelaychainClient for Arc<T>
+impl<RCInterface> RelaychainClient for RCInterface
 where
-	T: sc_client_api::BlockchainEvents<PBlock> + ProvideRuntimeApi<PBlock> + 'static + Send + Sync,
-	<T as ProvideRuntimeApi<PBlock>>::Api: ParachainHost<PBlock>,
+	RCInterface: RelayChainInterface + Clone + 'static,
 {
 	type Error = ClientError;
 
@@ -410,8 +407,7 @@ where
 		at: &BlockId<PBlock>,
 		para_id: ParaId,
 	) -> ClientResult<Option<Vec<u8>>> {
-		self.runtime_api()
-			.persisted_validation_data(at, para_id, OccupiedCoreAssumption::TimedOut)
+		self.persisted_validation_data(at, para_id, OccupiedCoreAssumption::TimedOut)
 			.map(|s| s.map(|s| s.parent_head.0))
 			.map_err(Into::into)
 	}

cumulus/client/consensus/relay-chain/Cargo.toml

@@ -19,11 +19,11 @@ sc-consensus = { git = "https://github.com/paritytech/substrate", branch = "mast
 substrate-prometheus-endpoint = { git = "https://github.com/paritytech/substrate", branch = "master" }
 
 # Polkadot dependencies
-polkadot-client = { git = "https://github.com/paritytech/polkadot", branch = "master" }
 
 # Cumulus dependencies
 cumulus-client-consensus-common = { path = "../common" }
 cumulus-primitives-core = { path = "../../../primitives/core" }
+cumulus-relay-chain-interface = { path = "../../relay-chain-interface" }
 
 # Other deps
 futures = { version = "0.3.8", features = ["compat"] }

cumulus/client/consensus/relay-chain/src/lib.rs

@@ -36,20 +36,16 @@
 use cumulus_client_consensus_common::{
 	ParachainBlockImport, ParachainCandidate, ParachainConsensus,
 };
-use cumulus_primitives_core::{
-	relay_chain::v1::{Block as PBlock, Hash as PHash, ParachainHost},
-	ParaId, PersistedValidationData,
-};
+use cumulus_primitives_core::{relay_chain::v1::Hash as PHash, ParaId, PersistedValidationData};
+use cumulus_relay_chain_interface::RelayChainInterface;
 use parking_lot::Mutex;
-use polkadot_client::ClientHandle;
-use sc_client_api::Backend;
+
 use sc_consensus::{BlockImport, BlockImportParams};
-use sp_api::ProvideRuntimeApi;
 use sp_consensus::{
 	BlockOrigin, EnableProofRecording, Environment, ProofRecording, Proposal, Proposer,
 };
 use sp_inherents::{CreateInherentDataProviders, InherentData, InherentDataProvider};
-use sp_runtime::traits::{Block as BlockT, HashFor, Header as HeaderT};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 use std::{marker::PhantomData, sync::Arc, time::Duration};
 
 mod import_queue;
@@ -58,18 +54,18 @@ pub use import_queue::{import_queue, Verifier};
 const LOG_TARGET: &str = "cumulus-consensus-relay-chain";
 
 /// The implementation of the relay-chain provided consensus for parachains.
-pub struct RelayChainConsensus<B, PF, BI, RClient, RBackend, CIDP> {
+pub struct RelayChainConsensus<B, PF, BI, RCInterface, CIDP> {
 	para_id: ParaId,
 	_phantom: PhantomData<B>,
 	proposer_factory: Arc<Mutex<PF>>,
 	create_inherent_data_providers: Arc<CIDP>,
 	block_import: Arc<futures::lock::Mutex<ParachainBlockImport<BI>>>,
-	relay_chain_client: Arc<RClient>,
-	relay_chain_backend: Arc<RBackend>,
+	relay_chain_interface: RCInterface,
 }
 
-impl<B, PF, BI, RClient, RBackend, CIDP> Clone
-	for RelayChainConsensus<B, PF, BI, RClient, RBackend, CIDP>
+impl<B, PF, BI, RCInterface, CIDP> Clone for RelayChainConsensus<B, PF, BI, RCInterface, CIDP>
+where
+	RCInterface: Clone,
 {
 	fn clone(&self) -> Self {
 		Self {
@@ -78,18 +74,15 @@ impl<B, PF, BI, RClient, RBackend, CIDP> Clone
 			proposer_factory: self.proposer_factory.clone(),
 			create_inherent_data_providers: self.create_inherent_data_providers.clone(),
 			block_import: self.block_import.clone(),
-			relay_chain_backend: self.relay_chain_backend.clone(),
-			relay_chain_client: self.relay_chain_client.clone(),
+			relay_chain_interface: self.relay_chain_interface.clone(),
 		}
 	}
 }
 
-impl<B, PF, BI, RClient, RBackend, CIDP> RelayChainConsensus<B, PF, BI, RClient, RBackend, CIDP>
+impl<B, PF, BI, RCInterface, CIDP> RelayChainConsensus<B, PF, BI, RCInterface, CIDP>
 where
 	B: BlockT,
-	RClient: ProvideRuntimeApi<PBlock>,
-	RClient::Api: ParachainHost<PBlock>,
-	RBackend: Backend<PBlock>,
+	RCInterface: RelayChainInterface,
 	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)>,
 {
 	/// Create a new instance of relay-chain provided consensus.
@@ -98,8 +91,7 @@ where
 		proposer_factory: PF,
 		create_inherent_data_providers: CIDP,
 		block_import: BI,
-		polkadot_client: Arc<RClient>,
-		polkadot_backend: Arc<RBackend>,
+		relay_chain_interface: RCInterface,
 	) -> Self {
 		Self {
 			para_id,
@@ -108,8 +100,7 @@ where
 			block_import: Arc::new(futures::lock::Mutex::new(ParachainBlockImport::new(
 				block_import,
 			))),
-			relay_chain_backend: polkadot_backend,
-			relay_chain_client: polkadot_client,
+			relay_chain_interface,
 			_phantom: PhantomData,
 		}
 	}
@@ -148,13 +139,11 @@ where
 }
 
 #[async_trait::async_trait]
-impl<B, PF, BI, RClient, RBackend, CIDP> ParachainConsensus<B>
-	for RelayChainConsensus<B, PF, BI, RClient, RBackend, CIDP>
+impl<B, PF, BI, RCInterface, CIDP> ParachainConsensus<B>
+	for RelayChainConsensus<B, PF, BI, RCInterface, CIDP>
 where
 	B: BlockT,
-	RClient: ProvideRuntimeApi<PBlock> + Send + Sync,
-	RClient::Api: ParachainHost<PBlock>,
-	RBackend: Backend<PBlock>,
+	RCInterface: RelayChainInterface + Clone,
 	BI: BlockImport<B> + Send + Sync,
 	PF: Environment<B> + Send + Sync,
 	PF::Proposer: Proposer<
@@ -229,27 +218,25 @@ where
 }
 
 /// Paramaters of [`build_relay_chain_consensus`].
-pub struct BuildRelayChainConsensusParams<PF, BI, RBackend, CIDP> {
+pub struct BuildRelayChainConsensusParams<PF, BI, CIDP, RCInterface> {
 	pub para_id: ParaId,
 	pub proposer_factory: PF,
 	pub create_inherent_data_providers: CIDP,
 	pub block_import: BI,
-	pub relay_chain_client: polkadot_client::Client,
-	pub relay_chain_backend: Arc<RBackend>,
+	pub relay_chain_interface: RCInterface,
 }
 
 /// Build the [`RelayChainConsensus`].
 ///
 /// Returns a boxed [`ParachainConsensus`].
-pub fn build_relay_chain_consensus<Block, PF, BI, RBackend, CIDP>(
+pub fn build_relay_chain_consensus<Block, PF, BI, CIDP, RCInterface>(
 	BuildRelayChainConsensusParams {
 		para_id,
 		proposer_factory,
 		create_inherent_data_providers,
 		block_import,
-		relay_chain_client,
-		relay_chain_backend,
-	}: BuildRelayChainConsensusParams<PF, BI, RBackend, CIDP>,
+		relay_chain_interface,
+	}: BuildRelayChainConsensusParams<PF, BI, CIDP, RCInterface>,
 ) -> Box<dyn ParachainConsensus<Block>>
 where
 	Block: BlockT,
@@ -261,108 +248,14 @@ where
 		Proof = <EnableProofRecording as ProofRecording>::Proof,
 	>,
 	BI: BlockImport<Block> + Send + Sync + 'static,
-	RBackend: Backend<PBlock> + 'static,
 	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)> + 'static,
+	RCInterface: RelayChainInterface + Clone + 'static,
 {
-	RelayChainConsensusBuilder::new(
+	Box::new(RelayChainConsensus::new(
 		para_id,
 		proposer_factory,
-		block_import,
 		create_inherent_data_providers,
-		relay_chain_client,
-		relay_chain_backend,
-	)
-	.build()
-}
-
-/// Relay chain consensus builder.
-///
-/// Builds a [`RelayChainConsensus`] for a parachain. As this requires
-/// a concrete relay chain client instance, the builder takes a [`polkadot_client::Client`]
-/// that wraps this concrete instanace. By using [`polkadot_client::ExecuteWithClient`]
-/// the builder gets access to this concrete instance.
-struct RelayChainConsensusBuilder<Block, PF, BI, RBackend, CIDP> {
-	para_id: ParaId,
-	_phantom: PhantomData<Block>,
-	proposer_factory: PF,
-	create_inherent_data_providers: CIDP,
-	block_import: BI,
-	relay_chain_backend: Arc<RBackend>,
-	relay_chain_client: polkadot_client::Client,
-}
-
-impl<Block, PF, BI, RBackend, CIDP> RelayChainConsensusBuilder<Block, PF, BI, RBackend, CIDP>
-where
-	Block: BlockT,
-	PF: Environment<Block> + Send + Sync + 'static,
-	PF::Proposer: Proposer<
-		Block,
-		Transaction = BI::Transaction,
-		ProofRecording = EnableProofRecording,
-		Proof = <EnableProofRecording as ProofRecording>::Proof,
-	>,
-	BI: BlockImport<Block> + Send + Sync + 'static,
-	RBackend: Backend<PBlock> + 'static,
-	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)> + 'static,
-{
-	/// Create a new instance of the builder.
-	fn new(
-		para_id: ParaId,
-		proposer_factory: PF,
-		block_import: BI,
-		create_inherent_data_providers: CIDP,
-		relay_chain_client: polkadot_client::Client,
-		relay_chain_backend: Arc<RBackend>,
-	) -> Self {
-		Self {
-			para_id,
-			_phantom: PhantomData,
-			proposer_factory,
-			block_import,
-			create_inherent_data_providers,
-			relay_chain_backend,
-			relay_chain_client,
-		}
-	}
-
-	/// Build the relay chain consensus.
-	fn build(self) -> Box<dyn ParachainConsensus<Block>> {
-		self.relay_chain_client.clone().execute_with(self)
-	}
-}
-
-impl<Block, PF, BI, RBackend, CIDP> polkadot_client::ExecuteWithClient
-	for RelayChainConsensusBuilder<Block, PF, BI, RBackend, CIDP>
-where
-	Block: BlockT,
-	PF: Environment<Block> + Send + Sync + 'static,
-	PF::Proposer: Proposer<
-		Block,
-		Transaction = BI::Transaction,
-		ProofRecording = EnableProofRecording,
-		Proof = <EnableProofRecording as ProofRecording>::Proof,
-	>,
-	BI: BlockImport<Block> + Send + Sync + 'static,
-	RBackend: Backend<PBlock> + 'static,
-	CIDP: CreateInherentDataProviders<Block, (PHash, PersistedValidationData)> + 'static,
-{
-	type Output = Box<dyn ParachainConsensus<Block>>;
-
-	fn execute_with_client<PClient, Api, PBackend>(self, client: Arc<PClient>) -> Self::Output
-	where
-		<Api as sp_api::ApiExt<PBlock>>::StateBackend: sp_api::StateBackend<HashFor<PBlock>>,
-		PBackend: Backend<PBlock>,
-		PBackend::State: sp_api::StateBackend<sp_runtime::traits::BlakeTwo256>,
-		Api: polkadot_client::RuntimeApiCollection<StateBackend = PBackend::State>,
-		PClient: polkadot_client::AbstractClient<PBlock, PBackend, Api = Api> + 'static,
-	{
-		Box::new(RelayChainConsensus::new(
-			self.para_id,
-			self.proposer_factory,
-			self.create_inherent_data_providers,
-			self.block_import,
-			client.clone(),
-			self.relay_chain_backend,
-		))
-	}
+		block_import,
+		relay_chain_interface,
+	))
 }