Remove service, migrate all to service-new (#1630)

* import rococo into chain-spec

* make a few stabs at moving forward

* wip: rococo readme

* remove /service crate

- Move the chain-spec files to node-service
- update sufficient cargo files that polkadot-service-new builds
- not everything else builds yet

* wip: chase down some build errors in polkadot-cli

There's a lot more to go, but some progress has happened.

* make more progress getting polkadot-cli to build

* don't ignore polkadot.json within the res directory

* don't recreate pathbufs

* Prepare Polkadot to be used by Cumulus

This begins to make Polkadot usable from Cumulus.

* Remove old test

* migrate new_chain_ops fix from /service

* partially remove node/test-service

* Reset some changes

* Revert "partially remove node/test-service"

This reverts commit 7b8f9ba5bfc286a309df89853ae11facf3277ffb.

* WIP: replace v0 ParachainHost impl with v1 for test runtime

This is necessary because one of the current errors when building
the test service boils down to:

the trait bound `polkadot_test_runtime::RuntimeApiImpl<...>`:
  `polkadot_primitives::v1::ParachainHost<...>` is not satisfied

This is WIP because it appears to be causing some std leakage into
the wasm environment, or something; the compiler is currently
complaining about duplicate definitions of `panic_handler` and `oom`.
Presumably I have to identify all std types (Vec etc) and replace
them with sp_std equivalents.

* fix test runtime build

it wasn't std leakage, after all

* bump westend spec version

* use service-new as service within cli

* to revert: demo that forwarding the test runtime to the real impl blows up

* Revert "to revert: demo that forwarding the test runtime to the real impl blows up"

This reverts commit 68d2f385f378721c7433e3e39133434610cd2a51.

* Revert "Revert "to revert: demo that forwarding the test runtime to the real impl blows up""

This reverts commit 04cb1cbf8873b4429cb9c9fdccb7f4bb137dc720.

Might have just forgotten to disable default features

* More reverts

* MOARE

* plug in the runtime as the generic instantiation

This feels closer to a solution, but it still has problems: in particular,
it's assumed that Runtime implements all appropriate Trait traits,
which this one apparently does not.

* implement necessary traits to get the test runtime compiling

This is almost certainly not correct in some way; it really
looks like I need to mess with the construct_runtime! macro
somehow, to inject the inclusion trait's event type as a Event
variant. Still, better lock down this changeset while it all
compiles.

* add inclusion::Event as variant into Event enum

* implement unimplemented bits in kusama

* implement unimplemented bits in polkadot runtime

* implement unimplemented bits in westend runtime

* migrate client upgrades from master

* update test service with new node changes

* package metadata--that wasn't intended to be removed

* add parachains v1 modules to each runtime

It's not clear what precisely this does, but it's probably the right
thing to do.

* enable cli to opt out of full node features

* adjust rococo chainspec per example

https://github.com/paritytech/polkadot/blob/26f1fa47f7836ab4bee5d4aad127ebce748320dd/service/src/chain_spec.rs#L362

* try to fix Cargo.lock

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: Andronik Ordian <write@reusable.software>

polkadot/node/service/src/client.rs

@@ -24,7 +24,7 @@ use sp_runtime::{
 };
 use sc_client_api::{Backend as BackendT, BlockchainEvents, KeyIterator};
 use sp_storage::{StorageData, StorageKey, ChildInfo, PrefixedStorageKey};
-use polkadot_primitives::v1::{Block, ParachainHost, AccountId, Nonce, Balance};
+use polkadot_primitives::v1::{Block, ParachainHost, AccountId, Nonce, Balance, Header, BlockNumber, Hash};
 use consensus_common::BlockStatus;
 
 /// A set of APIs that polkadot-like runtimes must implement.
@@ -142,6 +142,7 @@ pub enum Client {
 	Polkadot(Arc<crate::FullClient<polkadot_runtime::RuntimeApi, crate::PolkadotExecutor>>),
 	Westend(Arc<crate::FullClient<westend_runtime::RuntimeApi, crate::WestendExecutor>>),
 	Kusama(Arc<crate::FullClient<kusama_runtime::RuntimeApi, crate::KusamaExecutor>>),
+	Rococo(Arc<crate::FullClient<rococo_runtime::RuntimeApi, crate::RococoExecutor>>),
 }
 
 impl ClientHandle for Client {
@@ -156,6 +157,9 @@ impl ClientHandle for Client {
 			Self::Kusama(client) => {
 				T::execute_with_client::<_, _, crate::FullBackend>(t, client.clone())
 			},
+			Self::Rococo(client) => {
+				T::execute_with_client::<_, _, crate::FullBackend>(t, client.clone())
+			}
 		}
 	}
 }
@@ -166,6 +170,7 @@ impl sc_client_api::UsageProvider<Block> for Client {
 			Self::Polkadot(client) => client.usage_info(),
 			Self::Westend(client) => client.usage_info(),
 			Self::Kusama(client) => client.usage_info(),
+			Self::Rococo(client) => client.usage_info(),
 		}
 	}
 }
@@ -179,6 +184,7 @@ impl sc_client_api::BlockBackend<Block> for Client {
 			Self::Polkadot(client) => client.block_body(id),
 			Self::Westend(client) => client.block_body(id),
 			Self::Kusama(client) => client.block_body(id),
+			Self::Rococo(client) => client.block_body(id),
 		}
 	}
 
@@ -187,6 +193,7 @@ impl sc_client_api::BlockBackend<Block> for Client {
 			Self::Polkadot(client) => client.block(id),
 			Self::Westend(client) => client.block(id),
 			Self::Kusama(client) => client.block(id),
+			Self::Rococo(client) => client.block(id),
 		}
 	}
 
@@ -195,6 +202,7 @@ impl sc_client_api::BlockBackend<Block> for Client {
 			Self::Polkadot(client) => client.block_status(id),
 			Self::Westend(client) => client.block_status(id),
 			Self::Kusama(client) => client.block_status(id),
+			Self::Rococo(client) => client.block_status(id),
 		}
 	}
 
@@ -206,6 +214,7 @@ impl sc_client_api::BlockBackend<Block> for Client {
 			Self::Polkadot(client) => client.justification(id),
 			Self::Westend(client) => client.justification(id),
 			Self::Kusama(client) => client.justification(id),
+			Self::Rococo(client) => client.justification(id),
 		}
 	}
 
@@ -217,6 +226,7 @@ impl sc_client_api::BlockBackend<Block> for Client {
 			Self::Polkadot(client) => client.block_hash(number),
 			Self::Westend(client) => client.block_hash(number),
 			Self::Kusama(client) => client.block_hash(number),
+			Self::Rococo(client) => client.block_hash(number),
 		}
 	}
 }
@@ -231,6 +241,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.storage(id, key),
 			Self::Westend(client) => client.storage(id, key),
 			Self::Kusama(client) => client.storage(id, key),
+			Self::Rococo(client) => client.storage(id, key),
 		}
 	}
 
@@ -243,6 +254,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.storage_keys(id, key_prefix),
 			Self::Westend(client) => client.storage_keys(id, key_prefix),
 			Self::Kusama(client) => client.storage_keys(id, key_prefix),
+			Self::Rococo(client) => client.storage_keys(id, key_prefix),
 		}
 	}
 
@@ -255,6 +267,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.storage_hash(id, key),
 			Self::Westend(client) => client.storage_hash(id, key),
 			Self::Kusama(client) => client.storage_hash(id, key),
+			Self::Rococo(client) => client.storage_hash(id, key),
 		}
 	}
 
@@ -267,6 +280,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.storage_pairs(id, key_prefix),
 			Self::Westend(client) => client.storage_pairs(id, key_prefix),
 			Self::Kusama(client) => client.storage_pairs(id, key_prefix),
+			Self::Rococo(client) => client.storage_pairs(id, key_prefix),
 		}
 	}
 
@@ -280,6 +294,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.storage_keys_iter(id, prefix, start_key),
 			Self::Westend(client) => client.storage_keys_iter(id, prefix, start_key),
 			Self::Kusama(client) => client.storage_keys_iter(id, prefix, start_key),
+			Self::Rococo(client) => client.storage_keys_iter(id, prefix, start_key),
 		}
 	}
 
@@ -293,6 +308,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.child_storage(id, child_info, key),
 			Self::Westend(client) => client.child_storage(id, child_info, key),
 			Self::Kusama(client) => client.child_storage(id, child_info, key),
+			Self::Rococo(client) => client.child_storage(id, child_info, key),
 		}
 	}
 
@@ -306,6 +322,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.child_storage_keys(id, child_info, key_prefix),
 			Self::Westend(client) => client.child_storage_keys(id, child_info, key_prefix),
 			Self::Kusama(client) => client.child_storage_keys(id, child_info, key_prefix),
+			Self::Rococo(client) => client.child_storage_keys(id, child_info, key_prefix),
 		}
 	}
 
@@ -319,6 +336,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.child_storage_hash(id, child_info, key),
 			Self::Westend(client) => client.child_storage_hash(id, child_info, key),
 			Self::Kusama(client) => client.child_storage_hash(id, child_info, key),
+			Self::Rococo(client) => client.child_storage_hash(id, child_info, key),
 		}
 	}
 
@@ -331,6 +349,7 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.max_key_changes_range(first, last),
 			Self::Westend(client) => client.max_key_changes_range(first, last),
 			Self::Kusama(client) => client.max_key_changes_range(first, last),
+			Self::Rococo(client) => client.max_key_changes_range(first, last),
 		}
 	}
 
@@ -345,6 +364,54 @@ impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
 			Self::Polkadot(client) => client.key_changes(first, last, storage_key, key),
 			Self::Westend(client) => client.key_changes(first, last, storage_key, key),
 			Self::Kusama(client) => client.key_changes(first, last, storage_key, key),
+			Self::Rococo(client) => client.key_changes(first, last, storage_key, key),
+		}
+	}
+}
+
+impl sp_blockchain::HeaderBackend<Block> for Client {
+	fn header(&self, id: BlockId<Block>) -> sp_blockchain::Result<Option<Header>> {
+		match self {
+			Self::Polkadot(client) => client.header(&id),
+			Self::Westend(client) => client.header(&id),
+			Self::Kusama(client) => client.header(&id),
+			Self::Rococo(client) => client.header(&id),
+		}
+	}
+
+	fn info(&self) -> sp_blockchain::Info<Block> {
+		match self {
+			Self::Polkadot(client) => client.info(),
+			Self::Westend(client) => client.info(),
+			Self::Kusama(client) => client.info(),
+			Self::Rococo(client) => client.info(),
+		}
+	}
+
+	fn status(&self, id: BlockId<Block>) -> sp_blockchain::Result<sp_blockchain::BlockStatus> {
+		match self {
+			Self::Polkadot(client) => client.status(id),
+			Self::Westend(client) => client.status(id),
+			Self::Kusama(client) => client.status(id),
+			Self::Rococo(client) => client.status(id),
+		}
+	}
+
+	fn number(&self, hash: Hash) -> sp_blockchain::Result<Option<BlockNumber>> {
+		match self {
+			Self::Polkadot(client) => client.number(hash),
+			Self::Westend(client) => client.number(hash),
+			Self::Kusama(client) => client.number(hash),
+			Self::Rococo(client) => client.number(hash),
+		}
+	}
+
+	fn hash(&self, number: BlockNumber) -> sp_blockchain::Result<Option<Hash>> {
+		match self {
+			Self::Polkadot(client) => client.hash(number),
+			Self::Westend(client) => client.hash(number),
+			Self::Kusama(client) => client.hash(number),
+			Self::Rococo(client) => client.hash(number),
 		}
 	}
 }

polkadot/node/service/src/grandpa_support.rs

@@ -25,7 +25,8 @@ use sp_runtime::traits::{Block as BlockT, NumberFor};
 /// `N` + `M`, the voter will keep voting for block `N`.
 pub(crate) struct PauseAfterBlockFor<N>(pub(crate) N, pub(crate) N);
 
-impl<Block, B> grandpa::VotingRule<Block, B> for PauseAfterBlockFor<NumberFor<Block>> where
+impl<Block, B> grandpa::VotingRule<Block, B> for PauseAfterBlockFor<NumberFor<Block>>
+where
 	Block: BlockT,
 	B: sp_blockchain::HeaderBackend<Block>,
 {
@@ -40,10 +41,7 @@ impl<Block, B> grandpa::VotingRule<Block, B> for PauseAfterBlockFor<NumberFor<Bl
 		use sp_runtime::traits::Header as _;
 
 		// walk backwards until we find the target block
-		let find_target = |
-			target_number: NumberFor<Block>,
-			current_header: &Block::Header
-		| {
+		let find_target = |target_number: NumberFor<Block>, current_header: &Block::Header| {
 			let mut target_hash = current_header.hash();
 			let mut target_header = current_header.clone();
 
@@ -61,8 +59,9 @@ impl<Block, B> grandpa::VotingRule<Block, B> for PauseAfterBlockFor<NumberFor<Bl
 				}
 
 				target_hash = *target_header.parent_hash();
-				target_header = backend.header(BlockId::Hash(target_hash)).ok()?
-					.expect("Header known to exist due to the existence of one of its descendents; qed");
+				target_header = backend.header(BlockId::Hash(target_hash)).ok()?.expect(
+					"Header known to exist due to the existence of one of its descendents; qed",
+				);
 			}
 		};
 
@@ -233,10 +232,10 @@ pub(crate) fn kusama_hard_forks() -> Vec<(
 
 #[cfg(test)]
 mod tests {
+	use grandpa::VotingRule;
 	use polkadot_test_runtime_client::prelude::*;
 	use polkadot_test_runtime_client::sp_consensus::BlockOrigin;
 	use sc_block_builder::BlockBuilderProvider;
-	use grandpa::VotingRule;
 	use sp_blockchain::HeaderBackend;
 	use sp_runtime::generic::BlockId;
 	use sp_runtime::traits::Header;
@@ -279,20 +278,12 @@ mod tests {
 
 		// add 10 blocks
 		push_blocks(10);
-		assert_eq!(
-			client.info().best_number,
-			10,
-		);
+		assert_eq!(client.info().best_number, 10,);
 
 		// we have not reached the pause block
 		// therefore nothing should be restricted
 		assert_eq!(
-			voting_rule.restrict_vote(
-				&*client,
-				&get_header(0),
-				&get_header(10),
-				&get_header(10),
-			),
+			voting_rule.restrict_vote(&*client, &get_header(0), &get_header(10), &get_header(10),),
 			None,
 		);
 
@@ -303,12 +294,7 @@ mod tests {
 		// we are targeting the pause block,
 		// the vote should not be restricted
 		assert_eq!(
-			voting_rule.restrict_vote(
-				&*client,
-				&get_header(10),
-				&get_header(20),
-				&get_header(20),
-			),
+			voting_rule.restrict_vote(&*client, &get_header(10), &get_header(20), &get_header(20),),
 			None,
 		);
 
@@ -316,12 +302,7 @@ mod tests {
 		// be limited to the pause block.
 		let pause_block = get_header(20);
 		assert_eq!(
-			voting_rule.restrict_vote(
-				&*client,
-				&get_header(10),
-				&get_header(21),
-				&get_header(21),
-			),
+			voting_rule.restrict_vote(&*client, &get_header(10), &get_header(21), &get_header(21),),
 			Some((pause_block.hash(), *pause_block.number())),
 		);
 

polkadot/node/service/src/lib.rs

@@ -16,45 +16,49 @@
 
 //! Polkadot service. Specialized wrapper over substrate service.
 
-pub mod chain_spec;
 mod grandpa_support;
 mod client;
 
-use std::sync::Arc;
-use std::time::Duration;
-use service::{error::Error as ServiceError, RpcHandlers};
+pub mod chain_spec;
+
 use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
-use sc_executor::native_executor_instance;
 use log::info;
-use sp_blockchain::HeaderBackend;
+use polkadot_node_core_proposer::ProposerFactory;
 use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandler};
 use polkadot_subsystem::DummySubsystem;
-use polkadot_node_core_proposer::ProposerFactory;
-use sp_trie::PrefixedMemoryDB;
-use sp_core::traits::SpawnNamed;
+use prometheus_endpoint::Registry;
 use sc_client_api::ExecutorProvider;
+use sc_executor::native_executor_instance;
+use service::{error::Error as ServiceError, RpcHandlers};
+use sp_blockchain::HeaderBackend;
+use sp_core::traits::SpawnNamed;
+use sp_trie::PrefixedMemoryDB;
+use std::sync::Arc;
+use std::time::Duration;
+
+pub use self::client::{AbstractClient, Client, ClientHandle, ExecuteWithClient, RuntimeApiCollection};
+pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec, RococoChainSpec};
+#[cfg(feature = "full-node")]
+pub use codec::Codec;
+pub use consensus_common::{Proposal, SelectChain, BlockImport, RecordProof, block_validation::Chain};
+pub use polkadot_parachain::wasm_executor::run_worker as run_validation_worker;
+pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Id as ParaId};
+pub use sc_client_api::{Backend, ExecutionStrategy, CallExecutor};
+pub use sc_consensus::LongestChain;
+pub use sc_executor::NativeExecutionDispatch;
 pub use service::{
 	Role, PruningMode, TransactionPoolOptions, Error, RuntimeGenesis,
 	TFullClient, TLightClient, TFullBackend, TLightBackend, TFullCallExecutor, TLightCallExecutor,
 	Configuration, ChainSpec, TaskManager,
 };
 pub use service::config::{DatabaseConfig, PrometheusConfig};
-pub use sc_executor::NativeExecutionDispatch;
-pub use sc_client_api::{Backend, ExecutionStrategy, CallExecutor};
-pub use sc_consensus::LongestChain;
 pub use sp_api::{ApiRef, Core as CoreApi, ConstructRuntimeApi, ProvideRuntimeApi, StateBackend};
-pub use sp_runtime::traits::{DigestFor, HashFor, NumberFor};
-pub use consensus_common::{Proposal, SelectChain, BlockImport, RecordProof, block_validation::Chain};
-pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Id as ParaId};
-pub use sp_runtime::traits::{Block as BlockT, self as runtime_traits, BlakeTwo256};
-pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec};
-#[cfg(feature = "full-node")]
-pub use codec::Codec;
-pub use polkadot_runtime;
+pub use sp_runtime::traits::{DigestFor, HashFor, NumberFor, Block as BlockT, self as runtime_traits, BlakeTwo256};
+
 pub use kusama_runtime;
+pub use polkadot_runtime;
+pub use rococo_runtime;
 pub use westend_runtime;
-use prometheus_endpoint::Registry;
-pub use self::client::{AbstractClient, Client, RuntimeApiCollection};
 
 native_executor_instance!(
 	pub PolkadotExecutor,
@@ -77,6 +81,13 @@ native_executor_instance!(
 	frame_benchmarking::benchmarking::HostFunctions,
 );
 
+native_executor_instance!(
+	pub RococoExecutor,
+	rococo_runtime::api::dispatch,
+	rococo_runtime::native_version,
+	frame_benchmarking::benchmarking::HostFunctions,
+);
+
 /// Can be called for a `Configuration` to check if it is a configuration for the `Kusama` network.
 pub trait IdentifyVariant {
 	/// Returns if this is a configuration for the `Kusama` network.
@@ -84,6 +95,9 @@ pub trait IdentifyVariant {
 
 	/// Returns if this is a configuration for the `Westend` network.
 	fn is_westend(&self) -> bool;
+
+	/// Returns if this is a configuration for the `Rococo` network.
+	fn is_rococo(&self) -> bool;
 }
 
 impl IdentifyVariant for Box<dyn ChainSpec> {
@@ -93,6 +107,9 @@ impl IdentifyVariant for Box<dyn ChainSpec> {
 	fn is_westend(&self) -> bool {
 		self.id().starts_with("westend") || self.id().starts_with("wnd")
 	}
+	fn is_rococo(&self) -> bool {
+		self.id().starts_with("rococo") || self.id().starts_with("rco")
+	}
 }
 
 // If we're using prometheus, use a registry with a prefix of `polkadot`.
@@ -104,9 +121,9 @@ fn set_prometheus_registry(config: &mut Configuration) -> Result<(), ServiceErro
 	Ok(())
 }
 
-type FullBackend = service::TFullBackend<Block>;
+pub type FullBackend = service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
-type FullClient<RuntimeApi, Executor> = service::TFullClient<Block, RuntimeApi, Executor>;
+pub type FullClient<RuntimeApi, Executor> = service::TFullClient<Block, RuntimeApi, Executor>;
 type FullGrandpaBlockImport<RuntimeApi, Executor> = grandpa::GrandpaBlockImport<
 	FullBackend, Block, FullClient<RuntimeApi, Executor>, FullSelectChain
 >;
@@ -275,18 +292,40 @@ fn real_overseer<S: SpawnNamed>(
 }
 
 #[cfg(feature = "full-node")]
-fn new_full<RuntimeApi, Executor>(
+pub struct NewFull<C> {
+	pub task_manager: TaskManager,
+	pub client: C,
+	pub node_handles: OverseerHandler,
+	pub network: Arc<sc_network::NetworkService<Block, <Block as BlockT>::Hash>>,
+	pub network_status_sinks: service::NetworkStatusSinks<Block>,
+	pub rpc_handlers: RpcHandlers,
+}
+
+#[cfg(feature = "full-node")]
+impl<C> NewFull<C> {
+	fn with_client(self, func: impl FnOnce(C) -> Client) -> NewFull<Client> {
+		NewFull {
+			client: func(self.client),
+			task_manager: self.task_manager,
+			node_handles: self.node_handles,
+			network: self.network,
+			network_status_sinks: self.network_status_sinks,
+			rpc_handlers: self.rpc_handlers,
+		}
+	}
+}
+
+/// Create a new full node of arbitrary runtime and executor.
+///
+/// This is an advanced feature and not recommended for general use. Generally, `build_full` is
+/// a better choice.
+#[cfg(feature = "full-node")]
+pub fn new_full<RuntimeApi, Executor>(
 	mut config: Configuration,
 	collating_for: Option<(CollatorId, ParaId)>,
 	authority_discovery_enabled: bool,
 	grandpa_pause: Option<(u32, u32)>,
-) -> Result<(
-	TaskManager,
-	Arc<FullClient<RuntimeApi, Executor>>,
-	Arc<sc_network::NetworkService<Block, <Block as BlockT>::Hash>>,
-	RpcHandlers,
-	OverseerHandler,
-), Error>
+) -> Result<NewFull<Arc<FullClient<RuntimeApi, Executor>>>, Error>
 	where
 		RuntimeApi: ConstructRuntimeApi<Block, FullClient<RuntimeApi, Executor>> + Send + Sync + 'static,
 		RuntimeApi::RuntimeApi:
@@ -352,7 +391,8 @@ fn new_full<RuntimeApi, Executor>(
 		on_demand: None,
 		remote_blockchain: None,
 		telemetry_connection_sinks: telemetry_connection_sinks.clone(),
-		network_status_sinks, system_rpc_tx,
+		network_status_sinks: network_status_sinks.clone(),
+		system_rpc_tx,
 	})?;
 
 	let (block_import, link_half, babe_link) = import_setup;
@@ -467,10 +507,8 @@ fn new_full<RuntimeApi, Executor>(
 				grandpa::VotingRulesBuilder::default()
 					.add(grandpa_support::PauseAfterBlockFor(block, delay))
 					.build()
-			},
-			None =>
-				grandpa::VotingRulesBuilder::default()
-					.build(),
+			}
+			None => grandpa::VotingRulesBuilder::default().build(),
 		};
 
 		let grandpa_config = grandpa::GrandpaParams {
@@ -536,7 +574,14 @@ fn new_full<RuntimeApi, Executor>(
 
 	network_starter.start_network();
 
-	Ok((task_manager, client, network, rpc_handlers, handler))
+	Ok(NewFull {
+		task_manager,
+		client,
+		node_handles: handler,
+		network,
+		network_status_sinks,
+		rpc_handlers,
+	})
 }
 
 /// Builds a new service for a light client.
@@ -564,7 +609,9 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage
 	));
 
 	let grandpa_block_import = grandpa::light_block_import(
-		client.clone(), backend.clone(), &(client.clone() as Arc<_>),
+		client.clone(),
+		backend.clone(),
+		&(client.clone() as Arc<_>),
 		Arc::new(on_demand.checker().clone()),
 	)?;
 
@@ -612,7 +659,11 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage
 
 	if config.offchain_worker.enabled {
 		service::build_offchain_workers(
-			&config, backend.clone(), task_manager.spawn_handle(), client.clone(), network.clone(),
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
 		);
 	}
 
@@ -648,30 +699,41 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage
 
 /// Builds a new object suitable for chain operations.
 #[cfg(feature = "full-node")]
-pub fn new_chain_ops<Runtime, Dispatch>(mut config: &mut Configuration) -> Result<
+pub fn new_chain_ops(mut config: &mut Configuration) -> Result<
 	(
-		Arc<FullClient<Runtime, Dispatch>>,
+		Arc<Client>,
 		Arc<FullBackend>,
 		consensus_common::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
 		TaskManager,
 	),
 	ServiceError
 >
-where
-	Runtime: ConstructRuntimeApi<Block, FullClient<Runtime, Dispatch>> + Send + Sync + 'static,
-	Runtime::RuntimeApi:
-	RuntimeApiCollection<StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,
-	Dispatch: NativeExecutionDispatch + 'static,
 {
 	config.keystore = service::config::KeystoreConfig::InMemory;
-	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
-		= new_partial::<Runtime, Dispatch>(config)?;
-	Ok((client, backend, import_queue, task_manager))
+	if config.chain_spec.is_rococo() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<rococo_runtime::RuntimeApi, RococoExecutor>(config)?;
+		Ok((Arc::new(Client::Rococo(client)), backend, import_queue, task_manager))
+	} else if config.chain_spec.is_kusama() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<kusama_runtime::RuntimeApi, KusamaExecutor>(config)?;
+		Ok((Arc::new(Client::Kusama(client)), backend, import_queue, task_manager))
+	} else if config.chain_spec.is_westend() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<westend_runtime::RuntimeApi, WestendExecutor>(config)?;
+		Ok((Arc::new(Client::Westend(client)), backend, import_queue, task_manager))
+	} else {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(config)?;
+		Ok((Arc::new(Client::Polkadot(client)), backend, import_queue, task_manager))
+	}
 }
 
 /// Build a new light node.
 pub fn build_light(config: Configuration) -> Result<(TaskManager, RpcHandlers), ServiceError> {
-	if config.chain_spec.is_kusama() {
+	if config.chain_spec.is_rococo() {
+		new_light::<rococo_runtime::RuntimeApi, RococoExecutor>(config)
+	} else if config.chain_spec.is_kusama() {
 		new_light::<kusama_runtime::RuntimeApi, KusamaExecutor>(config)
 	} else if config.chain_spec.is_westend() {
 		new_light::<westend_runtime::RuntimeApi, WestendExecutor>(config)
@@ -686,27 +748,34 @@ pub fn build_full(
 	collating_for: Option<(CollatorId, ParaId)>,
 	authority_discovery_enabled: bool,
 	grandpa_pause: Option<(u32, u32)>,
-) -> Result<(TaskManager, Client, OverseerHandler), ServiceError> {
-	if config.chain_spec.is_kusama() {
+) -> Result<NewFull<Client>, ServiceError> {
+	if config.chain_spec.is_rococo() {
+		new_full::<rococo_runtime::RuntimeApi, RococoExecutor>(
+			config,
+			collating_for,
+			authority_discovery_enabled,
+			grandpa_pause,
+		).map(|full| full.with_client(Client::Rococo))
+	} else if config.chain_spec.is_kusama() {
 		new_full::<kusama_runtime::RuntimeApi, KusamaExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Kusama(client), handler))
+		).map(|full| full.with_client(Client::Kusama))
 	} else if config.chain_spec.is_westend() {
 		new_full::<westend_runtime::RuntimeApi, WestendExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Westend(client), handler))
+		).map(|full| full.with_client(Client::Westend))
 	} else {
 		new_full::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Polkadot(client), handler))
+		).map(|full| full.with_client(Client::Polkadot))
 	}
 }