Remove the service, replacing it with a struct of individual chain components

bin/node/cli/src/service.rs

@@ -463,6 +463,7 @@ mod tests {
 	use crate::service::{new_full_base, new_light_base};
 	use sp_runtime::traits::IdentifyAccount;
 	use sp_transaction_pool::{MaintainedTransactionPool, ChainEvent};
+	use sc_client_api::BlockBackend;
 
 	type AccountPublic = <Signature as Verify>::Signer;
 

bin/node/testing/src/bench.rs

@@ -55,7 +55,7 @@ use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder;
 use sp_inherents::InherentData;
 use sc_client_api::{
-	ExecutionStrategy,
+	ExecutionStrategy, BlockBackend,
 	execution_extensions::{ExecutionExtensions, ExecutionStrategies},
 };
 use sp_core::{Pair, Public, sr25519, ed25519};

client/api/src/client.rs

@@ -90,6 +90,9 @@ pub trait BlockBackend<Block: BlockT> {
 
 	/// Get block justification set by id.
 	fn justification(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<Justification>>;
+
+	/// Get block hash by number.
+	fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>>;
 }
 
 /// Provide a list of potential uncle headers for a given block.

client/finality-grandpa/src/light_import.rs

@@ -573,7 +573,7 @@ pub mod tests {
 	use sp_consensus::{import_queue::CacheKeyId, ForkChoiceStrategy, BlockImport};
 	use sp_finality_grandpa::AuthorityId;
 	use sp_core::{H256, crypto::Public};
-	use sc_client_api::{in_mem::Blockchain as InMemoryAuxStore, StorageProof};
+	use sc_client_api::{in_mem::Blockchain as InMemoryAuxStore, StorageProof, BlockBackend};
 	use substrate_test_runtime_client::runtime::{Block, Header};
 	use crate::tests::TestApi;
 	use crate::finality_proof::{

client/service/src/builder.rs

@@ -24,14 +24,13 @@ use crate::{
 	config::{Configuration, KeystoreConfig, PrometheusConfig, OffchainWorkerConfig},
 };
 use sc_client_api::{
-	self, light::RemoteBlockchain, execution_extensions::ExtensionsFactory,
-	ExecutorProvider, CallExecutor, ForkBlocks, BadBlocks, CloneableSpawn, UsageProvider,
-	backend::RemoteBackend,
+	self, light::RemoteBlockchain, execution_extensions::ExtensionsFactory, ExecutorProvider, 
+	ForkBlocks, BadBlocks, CloneableSpawn, UsageProvider, backend::RemoteBackend,
 };
 use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender, TracingUnboundedReceiver};
 use sc_chain_spec::get_extension;
 use sp_consensus::{
-	block_validation::{BlockAnnounceValidator, DefaultBlockAnnounceValidator},
+	block_validation::{BlockAnnounceValidator, DefaultBlockAnnounceValidator, Chain},
 	import_queue::ImportQueue,
 };
 use futures::{
@@ -46,9 +45,9 @@ use sc_network::NetworkService;
 use parking_lot::{Mutex, RwLock};
 use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{
-	Block as BlockT, NumberFor, SaturatedConversion, HashFor, Zero,
+	Block as BlockT, NumberFor, SaturatedConversion, HashFor, Zero, BlockIdTo,
 };
-use sp_api::ProvideRuntimeApi;
+use sp_api::{ProvideRuntimeApi, CallApiAt};
 use sc_executor::{NativeExecutor, NativeExecutionDispatch, RuntimeInfo};
 use std::{
 	collections::HashMap,
@@ -62,8 +61,14 @@ use prometheus_endpoint::Registry;
 use sc_client_db::{Backend, DatabaseSettings};
 use sp_core::traits::CodeExecutor;
 use sp_runtime::BuildStorage;
-use sc_client_api::execution_extensions::ExecutionExtensions;
+use sc_client_api::{
+	BlockBackend, BlockchainEvents,
+	backend::StorageProvider,
+	proof_provider::ProofProvider,
+	execution_extensions::ExecutionExtensions
+};
 use sp_core::storage::Storage;
+use sp_blockchain::{HeaderMetadata, HeaderBackend};
 use crate::{ServiceComponents, TelemetryOnConnectSinks, RpcHandlers, NetworkStatusSinks};
 
 pub type BackgroundTask = Pin<Box<dyn Future<Output=()> + Send>>;
@@ -879,11 +884,11 @@ pub trait ServiceBuilderCommand {
 	) -> Result<Storage, Error>;
 }
 
-impl<TBl, TRtApi, TBackend, TExec, TSc, TImpQu, TExPool, TRpc>
+impl<TBl, TRtApi, TBackend, TSc, TImpQu, TExPool, TRpc, TCl>
 ServiceBuilder<
 	TBl,
 	TRtApi,
-	Client<TBackend, TExec, TBl, TRtApi>,
+	TCl,
 	Arc<OnDemand<TBl>>,
 	TSc,
 	TImpQu,
@@ -893,8 +898,12 @@ ServiceBuilder<
 	TRpc,
 	TBackend,
 > where
-	Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi<TBl>,
-	<Client<TBackend, TExec, TBl, TRtApi> as ProvideRuntimeApi<TBl>>::Api:
+	TCl: ProvideRuntimeApi<TBl> + HeaderMetadata<TBl, Error=sp_blockchain::Error> + Chain<TBl> +
+	BlockBackend<TBl> + BlockIdTo<TBl, Error=sp_blockchain::Error> + ProofProvider<TBl> +
+	HeaderBackend<TBl> + BlockchainEvents<TBl> + ExecutorProvider<TBl> + UsageProvider<TBl> +
+	StorageProvider<TBl, TBackend> + CallApiAt<TBl, Error=sp_blockchain::Error> +
+	Send + 'static,
+	<TCl as ProvideRuntimeApi<TBl>>::Api:
 		sp_api::Metadata<TBl> +
 		sc_offchain::OffchainWorkerApi<TBl> +
 		sp_transaction_pool::runtime_api::TaggedTransactionQueue<TBl> +
@@ -904,7 +913,6 @@ ServiceBuilder<
 	TBl: BlockT,
 	TRtApi: 'static + Send + Sync,
 	TBackend: 'static + sc_client_api::backend::Backend<TBl> + Send,
-	TExec: 'static + CallExecutor<TBl> + Send + Sync + Clone,
 	TSc: Clone,
 	TImpQu: 'static + ImportQueue<TBl>,
 	TExPool: MaintainedTransactionPool<Block=TBl, Hash = <TBl as BlockT>::Hash> + MallocSizeOfWasm + 'static,
@@ -917,11 +925,7 @@ ServiceBuilder<
 		Ok(self)
 	}
 
-	fn build_common(self) -> Result<
-		ServiceComponents<TBl, TBackend, TExec, TRtApi, TSc, TExPool>, Error
-	>
-		where TExec: CallExecutor<TBl, Backend = TBackend>,
-	{
+	fn build_common(self) -> Result<ServiceComponents<TBl, TBackend, TSc, TExPool, TCl>, Error> {
 		let ServiceBuilder {
 			marker: _,
 			mut config,
@@ -940,14 +944,14 @@ ServiceBuilder<
 			block_announce_validator_builder,
 		} = self;
 
+		let chain_info = client.usage_info().chain;
+
 		sp_session::generate_initial_session_keys(
 			client.clone(),
-			&BlockId::Hash(client.chain_info().best_hash),
+			&BlockId::Hash(chain_info.best_hash),
 			config.dev_key_seed.clone().map(|s| vec![s]).unwrap_or_default(),
 		)?;
 
-		let chain_info = client.chain_info();
-
 		info!("📦 Highest known block at #{}", chain_info.best_number);
 		telemetry!(
 			SUBSTRATE_INFO;
@@ -1117,20 +1121,16 @@ ServiceBuilder<
 	}
 
 	/// Builds the light service.
-	pub fn build_light(self) -> Result<
-		ServiceComponents<TBl, TBackend, TExec, TRtApi, TSc, TExPool>, Error
-	>
-		where TExec: CallExecutor<TBl, Backend = TBackend>,
-	{
+	pub fn build_light(self) -> Result<ServiceComponents<TBl, TBackend, TSc, TExPool, TCl>, Error> {
 		self.build_common()
 	}
 }
 
-impl<TBl, TRtApi, TBackend, TExec, TSc, TImpQu, TExPool, TRpc>
+impl<TBl, TRtApi, TBackend, TSc, TImpQu, TExPool, TRpc, TCl>
 ServiceBuilder<
 	TBl,
 	TRtApi,
-	Client<TBackend, TExec, TBl, TRtApi>,
+	TCl,
 	Arc<OnDemand<TBl>>,
 	TSc,
 	TImpQu,
@@ -1140,8 +1140,12 @@ ServiceBuilder<
 	TRpc,
 	TBackend,
 > where
-	Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi<TBl>,
-	<Client<TBackend, TExec, TBl, TRtApi> as ProvideRuntimeApi<TBl>>::Api:
+	TCl: ProvideRuntimeApi<TBl> + HeaderMetadata<TBl, Error=sp_blockchain::Error> + Chain<TBl> +
+	BlockBackend<TBl> + BlockIdTo<TBl, Error=sp_blockchain::Error> + ProofProvider<TBl> +
+	HeaderBackend<TBl> + BlockchainEvents<TBl> + ExecutorProvider<TBl> + UsageProvider<TBl> +
+	StorageProvider<TBl, TBackend> + CallApiAt<TBl, Error=sp_blockchain::Error> +
+	Send + 'static,
+	<TCl as ProvideRuntimeApi<TBl>>::Api:
 		sp_api::Metadata<TBl> +
 		sc_offchain::OffchainWorkerApi<TBl> +
 		sp_transaction_pool::runtime_api::TaggedTransactionQueue<TBl> +
@@ -1151,7 +1155,6 @@ ServiceBuilder<
 	TBl: BlockT,
 	TRtApi: 'static + Send + Sync,
 	TBackend: 'static + sc_client_api::backend::Backend<TBl> + Send,
-	TExec: 'static + CallExecutor<TBl> + Send + Sync + Clone,
 	TSc: Clone,
 	TImpQu: 'static + ImportQueue<TBl>,
 	TExPool: MaintainedTransactionPool<Block = TBl, Hash = <TBl as BlockT>::Hash> +
@@ -1162,11 +1165,7 @@ ServiceBuilder<
 {
 
 	/// Builds the full service.
-	pub fn build_full(self) -> Result<
-		ServiceComponents<TBl, TBackend, TExec, TRtApi, TSc, TExPool>, Error
-	>
-		where TExec: CallExecutor<TBl, Backend = TBackend>,
-	{
+	pub fn build_full(self) -> Result<ServiceComponents<TBl, TBackend, TSc, TExPool, TCl>, Error> {
 		// make transaction pool available for off-chain runtime calls.
 		self.client.execution_extensions()
 			.register_transaction_pool(Arc::downgrade(&self.transaction_pool) as _);
@@ -1198,18 +1197,16 @@ async fn transaction_notifications<TBl, TExPool>(
 }
 
 // Periodically notify the telemetry.
-async fn telemetry_periodic_send<TBl, TBackend, TExec, TRtApi, TExPool>(
-	client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+async fn telemetry_periodic_send<TBl, TExPool, TCl>(
+	client: Arc<TCl>,
 	transaction_pool: Arc<TExPool>,
 	mut metrics_service: MetricsService,
 	network_status_sinks: Arc<Mutex<status_sinks::StatusSinks<(NetworkStatus<TBl>, NetworkState)>>>
 )
 	where
 		TBl: BlockT,
-		TExec: CallExecutor<TBl>,
-		Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi<TBl>,
+		TCl: ProvideRuntimeApi<TBl> + UsageProvider<TBl>,
 		TExPool: MaintainedTransactionPool<Block=TBl, Hash = <TBl as BlockT>::Hash>,
-		TBackend: sc_client_api::backend::Backend<TBl>,
 {
 	let (state_tx, state_rx) = tracing_unbounded::<(NetworkStatus<_>, NetworkState)>("mpsc_netstat1");
 	network_status_sinks.lock().push(std::time::Duration::from_millis(5000), state_tx);
@@ -1287,11 +1284,11 @@ fn build_telemetry<TBl: BlockT>(
 	(telemetry, future)
 }
 
-fn gen_handler<TBl, TBackend, TExec, TRtApi, TExPool, TRpc>(
+fn gen_handler<TBl, TBackend, TExPool, TRpc, TCl>(
 	deny_unsafe: sc_rpc::DenyUnsafe,
 	config: &Configuration,
 	task_manager: &TaskManager,
-	client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+	client: Arc<TCl>,
 	transaction_pool: Arc<TExPool>,
 	keystore: Arc<RwLock<Keystore>>,
 	on_demand: Option<Arc<OnDemand<TBl>>>,
@@ -1302,13 +1299,14 @@ fn gen_handler<TBl, TBackend, TExec, TRtApi, TExPool, TRpc>(
 ) -> jsonrpc_pubsub::PubSubHandler<sc_rpc::Metadata>
 	where
 		TBl: BlockT,
-		TExec: CallExecutor<TBl, Backend = TBackend> + Send + Sync + 'static,
-		TRtApi: Send + Sync + 'static,
-		Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi<TBl>,
+		TCl: ProvideRuntimeApi<TBl> + BlockchainEvents<TBl> + HeaderBackend<TBl> +
+		HeaderMetadata<TBl, Error=sp_blockchain::Error> + ExecutorProvider<TBl> +
+		CallApiAt<TBl, Error=sp_blockchain::Error> + ProofProvider<TBl> +
+		StorageProvider<TBl, TBackend> + BlockBackend<TBl> + Send + Sync + 'static,
 		TExPool: MaintainedTransactionPool<Block=TBl, Hash = <TBl as BlockT>::Hash> + 'static,
 		TBackend: sc_client_api::backend::Backend<TBl> + 'static,
 		TRpc: sc_rpc::RpcExtension<sc_rpc::Metadata>,
-		<Client<TBackend, TExec, TBl, TRtApi> as ProvideRuntimeApi<TBl>>::Api:
+		<TCl as ProvideRuntimeApi<TBl>>::Api:
 			sp_session::SessionKeys<TBl> +
 			sp_api::Metadata<TBl, Error = sp_blockchain::Error>,
 {
@@ -1377,15 +1375,14 @@ fn gen_handler<TBl, TBackend, TExec, TRtApi, TExPool, TRpc>(
 	))
 }
 
-fn build_network<TBl, TBackend, TExec, TRtApi, TExPool, TImpQu>(
+fn build_network<TBl, TExPool, TImpQu, TCl>(
 	config: &Configuration,
-	client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+	client: Arc<TCl>,
 	transaction_pool: Arc<TExPool>,
 	spawn_handle: SpawnTaskHandle,
 	on_demand: Option<Arc<OnDemand<TBl>>>,
 	block_announce_validator_builder: Option<Box<
-		dyn FnOnce(Arc<Client<TBackend, TExec, TBl, TRtApi>>) ->
-			Box<dyn BlockAnnounceValidator<TBl> + Send> + Send
+		dyn FnOnce(Arc<TCl>) -> Box<dyn BlockAnnounceValidator<TBl> + Send> + Send
 	>>,
 	finality_proof_request_builder: Option<BoxFinalityProofRequestBuilder<TBl>>,
 	finality_proof_provider: Option<Arc<dyn FinalityProofProvider<TBl>>>,
@@ -1401,11 +1398,10 @@ fn build_network<TBl, TBackend, TExec, TRtApi, TExPool, TImpQu>(
 >
 	where
 		TBl: BlockT,
-		TExec: CallExecutor<TBl> + Send + Sync + 'static,
-		TRtApi: Send + Sync + 'static,
-		Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi<TBl>,
+		TCl: ProvideRuntimeApi<TBl> + HeaderMetadata<TBl, Error=sp_blockchain::Error> + Chain<TBl> +
+		BlockBackend<TBl> + BlockIdTo<TBl, Error=sp_blockchain::Error> + ProofProvider<TBl> +
+		HeaderBackend<TBl> + BlockchainEvents<TBl> + 'static,
 		TExPool: MaintainedTransactionPool<Block=TBl, Hash = <TBl as BlockT>::Hash> + 'static,
-		TBackend: sc_client_api::backend::Backend<TBl> + 'static,
 		TImpQu: ImportQueue<TBl> + 'static,
 {
 	let transaction_pool_adapter = Arc::new(TransactionPoolAdapter {

client/service/src/client/client.rs

@@ -353,13 +353,6 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		self.executor.runtime_version(id)
 	}
 
-	/// Get block hash by number.
-	pub fn block_hash(&self,
-		block_number: <<Block as BlockT>::Header as HeaderT>::Number
-	) -> sp_blockchain::Result<Option<Block::Hash>> {
-		self.backend.blockchain().hash(block_number)
-	}
-
 	/// Reads given header and generates CHT-based header proof for CHT of given size.
 	pub fn header_proof_with_cht_size(
 		&self,
@@ -1925,6 +1918,10 @@ impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA>
 	fn justification(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<Justification>> {
 		self.backend.blockchain().justification(*id)
 	}
+
+	fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.backend.blockchain().hash(number)
+	}	
 }
 
 impl<B, E, Block, RA> backend::AuxStore for Client<B, E, Block, RA>

client/service/src/lib.rs

@@ -43,7 +43,6 @@ use wasm_timer::Instant;
 use std::task::Poll;
 use parking_lot::Mutex;
 
-use client::Client;
 use futures::{Future, FutureExt, Stream, StreamExt, compat::*};
 use sc_network::{NetworkStatus, network_state::NetworkState, PeerId};
 use log::{log, warn, debug, error, Level};
@@ -80,7 +79,7 @@ pub use sc_network::config::{
 pub use sc_tracing::TracingReceiver;
 pub use task_manager::SpawnTaskHandle;
 pub use task_manager::TaskManager;
-use sc_client_api::BlockchainEvents;
+use sc_client_api::{Backend, BlockchainEvents};
 
 const DEFAULT_PROTOCOL_ID: &str = "sup";
 
@@ -152,11 +151,9 @@ impl TelemetryOnConnectSinks {
 
 /// The individual components of the chain, built by the service builder. You are encouraged to
 /// deconstruct this into its fields.
-pub struct ServiceComponents<
-	TBl: BlockT, TBackend: sc_client_api::backend::Backend<TBl>, TExec, TRtApi, TSc, TExPool,
-> {
+pub struct ServiceComponents<TBl: BlockT, TBackend: Backend<TBl>, TSc, TExPool, TCl> {
 	/// A blockchain client.
-	pub client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+	pub client: Arc<TCl>,
 	/// A shared transaction pool instance.
 	pub transaction_pool: Arc<TExPool>,
 	/// The chain task manager. 
@@ -177,9 +174,7 @@ pub struct ServiceComponents<
 	pub telemetry_on_connect_sinks: TelemetryOnConnectSinks,
 	/// A shared offchain workers instance.
 	pub offchain_workers: Option<Arc<sc_offchain::OffchainWorkers<
-		Client<TBackend, TExec, TBl, TRtApi>,
-		TBackend::OffchainStorage,
-		TBl
+		TCl, TBackend::OffchainStorage, TBl
 	>>>,
 }
 

client/service/test/src/client/light.rs

@@ -40,7 +40,13 @@ use sp_api::{InitializeBlock, StorageTransactionCache, ProofRecorder, OffchainOv
 use sp_consensus::{BlockOrigin};
 use sc_executor::{NativeExecutor, WasmExecutionMethod, RuntimeVersion, NativeVersion};
 use sp_core::{H256, tasks::executor as tasks_executor, NativeOrEncoded};
-use sc_client_api::{blockchain::Info, backend::NewBlockState, Backend as ClientBackend, ProofProvider, in_mem::{Backend as InMemBackend, Blockchain as InMemoryBlockchain}, AuxStore, Storage, CallExecutor, cht, ExecutionStrategy, StorageProof, BlockImportOperation, RemoteCallRequest, StorageProvider, ChangesProof, RemoteBodyRequest, RemoteReadRequest, RemoteChangesRequest, FetchChecker, RemoteReadChildRequest, RemoteHeaderRequest};
+use sc_client_api::{
+	blockchain::Info, backend::NewBlockState, Backend as ClientBackend, ProofProvider,
+	in_mem::{Backend as InMemBackend, Blockchain as InMemoryBlockchain},
+	AuxStore, Storage, CallExecutor, cht, ExecutionStrategy, StorageProof, BlockImportOperation,
+	RemoteCallRequest, StorageProvider, ChangesProof, RemoteBodyRequest, RemoteReadRequest,
+	RemoteChangesRequest, FetchChecker, RemoteReadChildRequest, RemoteHeaderRequest, BlockBackend,
+};
 use sp_externalities::Extensions;
 use sc_block_builder::BlockBuilderProvider;
 use sp_blockchain::{

test-utils/client/src/client_ext.rs

@@ -19,6 +19,7 @@
 
 use sc_service::client::Client;
 use sc_client_api::backend::Finalizer;
+use sc_client_api::client::BlockBackend;
 use sp_consensus::{
 	BlockImportParams, BlockImport, BlockOrigin, Error as ConsensusError,
 	ForkChoiceStrategy,