One node two runtimes (#191)

* One node two runtimes

This enables the rococo-collator to run the normal and the contracts runtime.

* Fix tests

cumulus/rococo-parachains/src/service.rs

@@ -20,67 +20,74 @@ use cumulus_service::{
 	prepare_node_config, start_collator, start_full_node, StartCollatorParams, StartFullNodeParams,
 };
 use polkadot_primitives::v0::CollatorPair;
+use rococo_parachain_primitives::Block;
 use sc_executor::native_executor_instance;
 pub use sc_executor::NativeExecutor;
 use sc_informant::OutputFormat;
 use sc_service::{Configuration, PartialComponents, Role, TFullBackend, TFullClient, TaskManager};
+use sp_api::ConstructRuntimeApi;
 use sp_runtime::traits::BlakeTwo256;
 use sp_trie::PrefixedMemoryDB;
 use std::sync::Arc;
 
-// Our native executor instance.
+// Native executor instance.
 native_executor_instance!(
-	pub Executor,
+	pub RuntimeExecutor,
 	parachain_runtime::api::dispatch,
 	parachain_runtime::native_version,
 );
 
+// Native executor instance for the contracts runtime.
+native_executor_instance!(
+	pub ContractsRuntimeExecutor,
+	parachain_contracts_runtime::api::dispatch,
+	parachain_contracts_runtime::native_version,
+);
+
 /// Starts a `ServiceBuilder` for a full service.
 ///
 /// Use this macro if you don't actually need the full service, but just the builder in order to
 /// be able to perform chain operations.
-pub fn new_partial(
+pub fn new_partial<RuntimeApi, Executor>(
 	config: &mut Configuration,
 ) -> Result<
 	PartialComponents<
-		TFullClient<
-			parachain_runtime::opaque::Block,
-			parachain_runtime::RuntimeApi,
-			crate::service::Executor,
-		>,
-		TFullBackend<parachain_runtime::opaque::Block>,
+		TFullClient<Block, RuntimeApi, Executor>,
+		TFullBackend<Block>,
 		(),
-		sp_consensus::import_queue::BasicQueue<
-			parachain_runtime::opaque::Block,
-			PrefixedMemoryDB<BlakeTwo256>,
-		>,
-		sc_transaction_pool::FullPool<
-			parachain_runtime::opaque::Block,
-			TFullClient<
-				parachain_runtime::opaque::Block,
-				parachain_runtime::RuntimeApi,
-				crate::service::Executor,
-			>,
-		>,
+		sp_consensus::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
+		sc_transaction_pool::FullPool<Block, TFullClient<Block, RuntimeApi, Executor>>,
 		(),
 	>,
 	sc_service::Error,
-> {
+>
+where
+	RuntimeApi: ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, Executor>>
+		+ Send
+		+ Sync
+		+ 'static,
+	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
+		+ sp_api::Metadata<Block>
+		+ sp_session::SessionKeys<Block>
+		+ sp_api::ApiExt<
+			Block,
+			Error = sp_blockchain::Error,
+			StateBackend = sc_client_api::StateBackendFor<TFullBackend<Block>, Block>,
+		> + sp_offchain::OffchainWorkerApi<Block>
+		+ sp_block_builder::BlockBuilder<Block>,
+	sc_client_api::StateBackendFor<TFullBackend<Block>, Block>: sp_api::StateBackend<BlakeTwo256>,
+	Executor: sc_executor::NativeExecutionDispatch + 'static,
+{
 	let inherent_data_providers = sp_inherents::InherentDataProviders::new();
 
-	let (client, backend, keystore, task_manager) = sc_service::new_full_parts::<
-		parachain_runtime::opaque::Block,
-		parachain_runtime::RuntimeApi,
-		crate::service::Executor,
-	>(&config)?;
+	let (client, backend, keystore, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
 	let client = Arc::new(client);
-	//let select_chain = sc_consensus::LongestChain::new(backend.clone());
 
 	let registry = config.prometheus_registry();
 
 	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
 		config.transaction_pool.clone(),
-		//std::sync::Arc::new(pool_api),
 		config.prometheus_registry(),
 		task_manager.spawn_handle(),
 		client.clone(),
@@ -109,25 +116,39 @@ pub fn new_partial(
 	Ok(params)
 }
 
-/// Run a node with the given parachain `Configuration` and relay chain `Configuration`
+/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.
 ///
-/// This function blocks until done.
-pub fn run_node(
+/// This is the actual implementation that is abstract over the executor and the runtime api.
+fn start_node_impl<RuntimeApi, Executor, RB>(
 	parachain_config: Configuration,
 	collator_key: Arc<CollatorPair>,
 	mut polkadot_config: polkadot_collator::Configuration,
 	id: polkadot_primitives::v0::Id,
 	validator: bool,
-) -> sc_service::error::Result<(
-	TaskManager,
-	Arc<
-		TFullClient<
-			parachain_runtime::opaque::Block,
-			parachain_runtime::RuntimeApi,
-			crate::service::Executor,
-		>,
-	>,
-)> {
+	rpc_ext_builder: RB,
+) -> sc_service::error::Result<(TaskManager, Arc<TFullClient<Block, RuntimeApi, Executor>>)>
+where
+	RuntimeApi: ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, Executor>>
+		+ Send
+		+ Sync
+		+ 'static,
+	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
+		+ sp_api::Metadata<Block>
+		+ sp_session::SessionKeys<Block>
+		+ sp_api::ApiExt<
+			Block,
+			Error = sp_blockchain::Error,
+			StateBackend = sc_client_api::StateBackendFor<TFullBackend<Block>, Block>,
+		> + sp_offchain::OffchainWorkerApi<Block>
+		+ sp_block_builder::BlockBuilder<Block>,
+	sc_client_api::StateBackendFor<TFullBackend<Block>, Block>: sp_api::StateBackend<BlakeTwo256>,
+	Executor: sc_executor::NativeExecutionDispatch + 'static,
+	RB: Fn(
+			Arc<TFullClient<Block, RuntimeApi, Executor>>,
+		) -> jsonrpc_core::IoHandler<sc_rpc::Metadata>
+		+ Send
+		+ 'static,
+{
 	if matches!(parachain_config.role, Role::Light) {
 		return Err("Light client not supported!".into());
 	}
@@ -143,7 +164,7 @@ pub fn run_node(
 		prefix: format!("[{}] ", Color::Blue.bold().paint("Relaychain")),
 	};
 
-	let params = new_partial(&mut parachain_config)?;
+	let params = new_partial::<RuntimeApi, Executor>(&mut parachain_config)?;
 	params
 		.inherent_data_providers
 		.register_provider(sp_timestamp::InherentDataProvider)
@@ -163,32 +184,21 @@ pub fn run_node(
 	let import_queue = params.import_queue;
 	let (network, network_status_sinks, system_rpc_tx, start_network) =
 		sc_service::build_network(sc_service::BuildNetworkParams {
-				config: &parachain_config,
-				client: client.clone(),
-				transaction_pool: transaction_pool.clone(),
-				spawn_handle: task_manager.spawn_handle(),
-				import_queue,
-				on_demand: None,
-				block_announce_validator_builder: Some(Box::new(block_announce_validator_builder)),
-				finality_proof_request_builder: None,
-				finality_proof_provider: None,
+			config: &parachain_config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			on_demand: None,
+			block_announce_validator_builder: Some(Box::new(block_announce_validator_builder)),
+			finality_proof_request_builder: None,
+			finality_proof_provider: None,
 		})?;
 
 	let rpc_extensions_builder = {
-		let _client = client.clone();
+		let client = client.clone();
 
-		Box::new(move |_deny_unsafe| {
-			let io = jsonrpc_core::IoHandler::default();
-
-			// TODO: add this rpc when running the contracts runtime
-			/*
-			use pallet_contracts_rpc::{Contracts, ContractsApi};
-			io.extend_with(
-				ContractsApi::to_delegate(Contracts::new(client.clone()))
-			);
-			*/
-			io
-		})
+		Box::new(move |_deny_unsafe| rpc_ext_builder(client.clone()))
 	};
 
 	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
@@ -249,3 +259,49 @@ pub fn run_node(
 
 	Ok((task_manager, client))
 }
+
+/// Start a normal parachain node.
+pub fn start_node(
+	parachain_config: Configuration,
+	collator_key: Arc<CollatorPair>,
+	polkadot_config: polkadot_collator::Configuration,
+	id: polkadot_primitives::v0::Id,
+	validator: bool,
+) -> sc_service::error::Result<(
+	TaskManager,
+	Arc<TFullClient<Block, parachain_runtime::RuntimeApi, RuntimeExecutor>>,
+)> {
+	start_node_impl::<parachain_runtime::RuntimeApi, RuntimeExecutor, _>(
+		parachain_config,
+		collator_key,
+		polkadot_config,
+		id,
+		validator,
+		|_| Default::default(),
+	)
+}
+
+/// Start a contracts parachain node.
+pub fn start_contracts_node(
+	parachain_config: Configuration,
+	collator_key: Arc<CollatorPair>,
+	polkadot_config: polkadot_collator::Configuration,
+	id: polkadot_primitives::v0::Id,
+	validator: bool,
+) -> sc_service::error::Result<TaskManager> {
+	start_node_impl::<parachain_contracts_runtime::RuntimeApi, ContractsRuntimeExecutor, _>(
+		parachain_config,
+		collator_key,
+		polkadot_config,
+		id,
+		validator,
+		|client| {
+			let mut io = jsonrpc_core::IoHandler::default();
+
+			use cumulus_pallet_contracts_rpc::{Contracts, ContractsApi};
+			io.extend_with(ContractsApi::to_delegate(Contracts::new(client)));
+			io
+		},
+	)
+	.map(|r| r.0)
+}