Update to latest Substrate & Polkadot (#131)

* Switch to latest Substrate & Polkadot

* Update again

cumulus/collator/src/lib.rs

@@ -20,8 +20,12 @@ use cumulus_network::{
 	DelayedBlockAnnounceValidator, JustifiedBlockAnnounceValidator, WaitToAnnounce,
 };
 use cumulus_primitives::{
-	inherents::{VALIDATION_FUNCTION_PARAMS_IDENTIFIER as VFP_IDENT, DOWNWARD_MESSAGES_IDENTIFIER, DownwardMessagesType},
-	validation_function_params::ValidationFunctionParams, HeadData,
+	inherents::{
+		DownwardMessagesType, DOWNWARD_MESSAGES_IDENTIFIER,
+		VALIDATION_FUNCTION_PARAMS_IDENTIFIER as VFP_IDENT,
+	},
+	validation_function_params::ValidationFunctionParams,
+	HeadData,
 };
 use cumulus_runtime::ParachainBlockData;
 
@@ -37,8 +41,7 @@ use sp_inherents::{InherentData, InherentDataProviders};
 use sp_runtime::traits::{Block as BlockT, HashFor, Header as HeaderT};
 
 use polkadot_collator::{
-	BuildParachainContext, InvalidHead, Network as CollatorNetwork, ParachainContext,
-	RuntimeApiCollection,
+	BuildParachainContext, Network as CollatorNetwork, ParachainContext, RuntimeApiCollection,
 };
 use polkadot_primitives::{
 	parachain::{self, BlockData, GlobalValidationSchedule, Id as ParaId, LocalValidationData},
@@ -99,15 +102,17 @@ impl<Block: BlockT, PF, BI> Collator<Block, PF, BI> {
 		global_validation: GlobalValidationSchedule,
 		local_validation: LocalValidationData,
 		downward_messages: DownwardMessagesType,
-	) -> Result<InherentData, InvalidHead> {
-		let mut inherent_data = inherent_providers.create_inherent_data().map_err(|e| {
-			error!(
-				target: "cumulus-collator",
-				"Failed to create inherent data: {:?}",
-				e,
-			);
-			InvalidHead
-		})?;
+	) -> Option<InherentData> {
+		let mut inherent_data = inherent_providers
+			.create_inherent_data()
+			.map_err(|e| {
+				error!(
+					target: "cumulus-collator",
+					"Failed to create inherent data: {:?}",
+					e,
+				);
+			})
+			.ok()?;
 
 		inherent_data
 			.put_data(
@@ -120,24 +125,21 @@ impl<Block: BlockT, PF, BI> Collator<Block, PF, BI> {
 					"Failed to put validation function params into inherent data: {:?}",
 					e,
 				);
-				InvalidHead
-			})?;
+			})
+			.ok()?;
 
 		inherent_data
-			.put_data(
-				DOWNWARD_MESSAGES_IDENTIFIER,
-				&downward_messages,
-			)
+			.put_data(DOWNWARD_MESSAGES_IDENTIFIER, &downward_messages)
 			.map_err(|e| {
 				error!(
 					target: "cumulus-collator",
 					"Failed to put downward messages into inherent data: {:?}",
 					e,
 				);
-				InvalidHead
-			})?;
+			})
+			.ok()?;
 
-		Ok(inherent_data)
+		Some(inherent_data)
 	}
 }
 
@@ -168,7 +170,7 @@ where
 		+ 'static,
 {
 	type ProduceCandidate =
-		Pin<Box<dyn Future<Output = Result<(BlockData, parachain::HeadData), InvalidHead>> + Send>>;
+		Pin<Box<dyn Future<Output = Option<(BlockData, parachain::HeadData)>> + Send>>;
 
 	fn produce_candidate(
 		&mut self,
@@ -187,7 +189,7 @@ where
 			Ok(x) => x,
 			Err(e) => {
 				error!(target: "cumulus-collator", "Could not decode the head data: {:?}", e);
-				return Box::pin(future::ready(Err(InvalidHead)));
+				return Box::pin(future::ready(None));
 			}
 		};
 
@@ -196,14 +198,16 @@ where
 		let wait_to_announce = self.wait_to_announce.clone();
 
 		Box::pin(async move {
-			let proposer = proposer_future.await.map_err(|e| {
-				error!(
-					target: "cumulus-collator",
-					"Could not create proposer: {:?}",
-					e,
-				);
-				InvalidHead
-			})?;
+			let proposer = proposer_future
+				.await
+				.map_err(|e| {
+					error!(
+						target: "cumulus-collator",
+						"Could not create proposer: {:?}",
+						e,
+					);
+				})
+				.ok()?;
 
 			let inherent_data = Self::inherent_data(
 				inherent_providers,
@@ -231,16 +235,20 @@ where
 						"Proposing failed: {:?}",
 						e,
 					);
-					InvalidHead
-				})?;
+				})
+				.ok()?;
 
-			let proof = proof.ok_or_else(|| {
-				error!(
-					target: "cumulus-collator",
-					"Proposer did not return the requested proof.",
-				);
-				InvalidHead
-			})?;
+			let proof = match proof {
+				Some(proof) => proof,
+				None => {
+					error!(
+						target: "cumulus-collator",
+						"Proposer did not return the requested proof.",
+					);
+
+					return None;
+				}
+			};
 
 			let (header, extrinsics) = block.deconstruct();
 
@@ -266,7 +274,8 @@ where
 					b.header().parent_hash(),
 					err,
 				);
-				return Err(InvalidHead);
+
+				return None;
 			}
 
 			let block_data = BlockData(b.encode());
@@ -283,7 +292,7 @@ where
 
 			trace!(target: "cumulus-collator", "Produced candidate: {:?}", candidate);
 
-			Ok(candidate)
+			Some(candidate)
 		})
 	}
 }

cumulus/consensus/src/import_queue.rs

@@ -101,7 +101,7 @@ pub fn import_queue<Client, Block: BlockT, I>(
 	client: Arc<Client>,
 	block_import: I,
 	inherent_data_providers: InherentDataProviders,
-	spawner: &impl sp_core::traits::SpawnBlocking,
+	spawner: &impl sp_core::traits::SpawnNamed,
 	registry: Option<&substrate_prometheus_endpoint::Registry>,
 ) -> ClientResult<BasicQueue<Block, I::Transaction>>
 where

cumulus/network/src/lib.rs

@@ -105,7 +105,7 @@ where
 
 				Validation::Failure
 			} else {
-				Validation::Success
+				Validation::Success { is_new_best: false }
 			});
 		}
 
@@ -202,7 +202,7 @@ where
 			)) as Box<_>);
 		}
 
-		Ok(Validation::Success)
+		Ok(Validation::Success { is_new_best: false })
 	}
 }
 

cumulus/network/src/tests.rs

@@ -104,7 +104,7 @@ fn valid_if_no_data_and_less_than_best_known_number() {
 
 	assert_eq!(
 		res.unwrap(),
-		Validation::Success,
+		Validation::Success { is_new_best: false },
 		"validating without data with block number < best known number is always a success",
 	);
 }

cumulus/parachain-upgrade/src/lib.rs

@@ -233,14 +233,16 @@ mod tests {
 
 	use codec::Encode;
 	use frame_support::{
-		assert_ok, impl_outer_event, impl_outer_origin, parameter_types,
+		assert_ok,
+		dispatch::UnfilteredDispatchable,
+		impl_outer_event, impl_outer_origin, parameter_types,
 		traits::{OnFinalize, OnInitialize},
 		weights::Weight,
 	};
 	use sp_core::H256;
 	use sp_runtime::{
 		testing::Header,
-		traits::{BlakeTwo256, Dispatchable, IdentityLookup},
+		traits::{BlakeTwo256, IdentityLookup},
 		Perbill,
 	};
 	use sp_version::RuntimeVersion;
@@ -305,6 +307,7 @@ mod tests {
 		type DbWeight = ();
 		type BlockExecutionWeight = ();
 		type ExtrinsicBaseWeight = ();
+		type BaseCallFilter = ();
 	}
 	impl Trait for Test {
 		type Event = TestEvent;
@@ -472,7 +475,7 @@ mod tests {
 					ParachainUpgrade::on_initialize(*n);
 					ParachainUpgrade::create_inherent(&inherent_data)
 						.expect("got an inherent")
-						.dispatch(RawOrigin::None.into())
+						.dispatch_bypass_filter(RawOrigin::None.into())
 						.expect("dispatch succeeded");
 					within_block();
 					ParachainUpgrade::on_finalize(*n);

cumulus/runtime/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2018"
 codec = { package = "parity-scale-codec", version = "1.3.0", default-features = false, features = [ "derive" ] }
 memory-db = { version = "0.18.0", default-features = false }
 hash-db = { version = "0.15.2", default-features = false }
-trie-db = { version = "0.20.1", default-features = false }
+trie-db = { version = "0.21.0", default-features = false }
 hashbrown = "0.6.1"
 
 # Cumulus dependencies

cumulus/test/parachain/Cargo.toml

@@ -39,6 +39,7 @@ sc-network = { git = "https://github.com/paritytech/substrate", branch = "cumulu
 sc-basic-authorship = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch", version = "0.8.0-alpha.5" }
 sp-timestamp = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 sc-finality-grandpa = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
+sc-informant = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 
 # Cumulus dependencies
 cumulus-consensus = { path = "../../consensus" }

cumulus/test/parachain/runtime/src/lib.rs

@@ -191,6 +191,7 @@ impl frame_system::Trait for Runtime {
 	type ExtrinsicBaseWeight = ExtrinsicBaseWeight;
 	type BlockExecutionWeight = ();
 	type MaximumExtrinsicWeight = MaximumExtrinsicWeight;
+	type BaseCallFilter = ();
 }
 
 parameter_types! {

cumulus/test/parachain/src/command.rs

@@ -17,14 +17,14 @@
 use crate::chain_spec;
 use crate::cli::{Cli, PolkadotCli, Subcommand};
 use codec::Encode;
+use cumulus_primitives::ParaId;
 use log::info;
 use parachain_runtime::Block;
 use polkadot_parachain::primitives::AccountIdConversion;
 use sc_cli::{
-	CliConfiguration, Error, ImportParams, KeystoreParams, NetworkParams, Result, SharedParams,
-	SubstrateCli,
+	ChainSpec, CliConfiguration, Error, ImportParams, KeystoreParams, NetworkParams, Result, Role,
+	RuntimeVersion, SharedParams, SubstrateCli,
 };
-use sc_executor::NativeExecutionDispatch;
 use sc_service::config::{BasePath, PrometheusConfig};
 use sp_core::hexdisplay::HexDisplay;
 use sp_runtime::{
@@ -32,7 +32,6 @@ use sp_runtime::{
 	BuildStorage,
 };
 use std::{net::SocketAddr, sync::Arc};
-use cumulus_primitives::ParaId;
 
 impl SubstrateCli for Cli {
 	fn impl_name() -> &'static str {
@@ -68,7 +67,13 @@ impl SubstrateCli for Cli {
 
 	fn load_spec(&self, _id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
 		// Such a hack :(
-		Ok(Box::new(chain_spec::get_chain_spec(self.run.parachain_id.into())))
+		Ok(Box::new(chain_spec::get_chain_spec(
+			self.run.parachain_id.into(),
+		)))
+	}
+
+	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
+		&parachain_runtime::VERSION
 	}
 }
 
@@ -114,6 +119,10 @@ impl SubstrateCli for PolkadotCli {
 			)?),
 		})
 	}
+
+	fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
+		polkadot_cli::Cli::native_runtime_version(chain_spec)
+	}
 }
 
 fn generate_genesis_state(para_id: ParaId) -> Result<Block> {
@@ -180,22 +189,18 @@ pub fn run() -> Result<()> {
 				))
 			};
 
-			runner.run_node(
-				|config| polkadot_service::polkadot_new_light(config),
-				|config| {
-					polkadot_service::polkadot_new_full(
-						config,
-						None,
-						None,
-						authority_discovery_enabled,
-						6000,
-						grandpa_pause,
-						None,
-					)
-					.map(|(s, _, _)| s)
-				},
-				polkadot_service::PolkadotExecutor::native_version().runtime_version,
-			)
+			runner.run_node_until_exit(|config| match config.role {
+				Role::Light => polkadot_service::polkadot_new_light(config).map(|r| r.0),
+				_ => polkadot_service::polkadot_new_full(
+					config,
+					None,
+					None,
+					authority_discovery_enabled,
+					6000,
+					grandpa_pause,
+				)
+				.map(|(s, _, _)| s),
+			})
 		}
 		Some(Subcommand::PolkadotValidationWorker(cmd)) => {
 			sc_cli::init_logger("");
@@ -223,27 +228,25 @@ pub fn run() -> Result<()> {
 			let block = generate_genesis_state(id)?;
 			let genesis_state = format!("0x{:?}", HexDisplay::from(&block.header().encode()));
 
-			runner.run_full_node(
-				|config| {
-					polkadot_cli.base_path =
-						config.base_path.as_ref().map(|x| x.path().join("polkadot"));
+			runner.run_node_until_exit(|config| {
+				if matches!(config.role, Role::Light) {
+					return Err("Light client not supporter!".into());
+				}
 
-					let task_executor = config.task_executor.clone();
-					let polkadot_config = SubstrateCli::create_configuration(
-						&polkadot_cli,
-						&polkadot_cli,
-						task_executor,
-					)
-					.unwrap();
+				polkadot_cli.base_path =
+					config.base_path.as_ref().map(|x| x.path().join("polkadot"));
 
-					info!("Parachain id: {:?}", id);
-					info!("Parachain Account: {}", parachain_account);
-					info!("Parachain genesis state: {}", genesis_state);
+				let task_executor = config.task_executor.clone();
+				let polkadot_config =
+					SubstrateCli::create_configuration(&polkadot_cli, &polkadot_cli, task_executor)
+						.unwrap();
 
-					crate::service::run_collator(config, key, polkadot_config, id)
-				},
-				parachain_runtime::VERSION,
-			)
+				info!("Parachain id: {:?}", id);
+				info!("Parachain Account: {}", parachain_account);
+				info!("Parachain genesis state: {}", genesis_state);
+
+				crate::service::run_collator(config, key, polkadot_config, id)
+			})
 		}
 	}
 }
@@ -269,8 +272,7 @@ impl CliConfiguration for PolkadotCli {
 		Ok(self
 			.shared_params()
 			.base_path()
-			.or_else(|| self.base_path.clone().map(Into::into))
-		)
+			.or_else(|| self.base_path.clone().map(Into::into)))
 	}
 
 	fn rpc_http(&self) -> Result<Option<SocketAddr>> {

cumulus/test/parachain/src/service.rs

@@ -24,7 +24,8 @@ pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::{
 	FinalityProofProvider as GrandpaFinalityProofProvider, StorageAndProofProvider,
 };
-use sc_service::{AbstractService, Configuration};
+use sc_informant::OutputFormat;
+use sc_service::{Configuration, TaskManager};
 use std::sync::Arc;
 
 // Our native executor instance.
@@ -71,7 +72,7 @@ macro_rules! new_full_start {
 		})?;
 
 		(builder, inherent_data_providers)
-		}};
+	}};
 }
 
 /// Run a collator node with the given parachain `Configuration` and relaychain `Configuration`
@@ -80,10 +81,15 @@ macro_rules! new_full_start {
 pub fn run_collator(
 	parachain_config: Configuration,
 	key: Arc<CollatorPair>,
-	polkadot_config: polkadot_collator::Configuration,
+	mut polkadot_config: polkadot_collator::Configuration,
 	id: polkadot_primitives::parachain::Id,
-) -> sc_service::error::Result<impl AbstractService> {
-	let parachain_config = prepare_collator_config(parachain_config);
+) -> sc_service::error::Result<TaskManager> {
+	let mut parachain_config = prepare_collator_config(parachain_config);
+
+	parachain_config.informant_output_format = OutputFormat {
+		enable_color: true,
+		prefix: format!("[{}] ", Color::Yellow.bold().paint("Parachain")),
+	};
 
 	let (builder, inherent_data_providers) = new_full_start!(parachain_config);
 	inherent_data_providers
@@ -93,7 +99,6 @@ pub fn run_collator(
 	let block_announce_validator = DelayedBlockAnnounceValidator::new();
 	let block_announce_validator_copy = block_announce_validator.clone();
 	let service = builder
-		.with_informant_prefix(format!("[{}] ", Color::Yellow.bold().paint("Parachain")))?
 		.with_finality_proof_provider(|client, backend| {
 			// GenesisAuthoritySetProvider is implemented for StorageAndProofProvider
 			let provider = client as Arc<dyn StorageAndProofProvider<_, _>>;
@@ -102,17 +107,17 @@ pub fn run_collator(
 		.with_block_announce_validator(|_client| Box::new(block_announce_validator_copy))?
 		.build_full()?;
 
-	let registry = service.prometheus_registry();
+	let registry = service.prometheus_registry.clone();
 
 	let proposer_factory = sc_basic_authorship::ProposerFactory::new(
-		service.client(),
-		service.transaction_pool(),
+		service.client.clone(),
+		service.transaction_pool.clone(),
 		registry.as_ref(),
 	);
 
-	let block_import = service.client();
-	let client = service.client();
-	let network = service.network();
+	let block_import = service.client.clone();
+	let client = service.client.clone();
+	let network = service.network.clone();
 	let announce_block = Arc::new(move |hash, data| network.announce_block(hash, data));
 	let builder = CollatorBuilder::new(
 		proposer_factory,
@@ -124,15 +129,14 @@ pub fn run_collator(
 		block_announce_validator,
 	);
 
-	let polkadot_future = polkadot_collator::start_collator(
-		builder,
-		id,
-		key,
-		polkadot_config,
-		Some(format!("[{}] ", Color::Blue.bold().paint("Relaychain"))),
-	)
-	.map(|_| ());
-	service.spawn_essential_task("polkadot", polkadot_future);
+	polkadot_config.informant_output_format = OutputFormat {
+		enable_color: true,
+		prefix: format!("[{}] ", Color::Blue.bold().paint("Relaychain")),
+	};
 
-	Ok(service)
+	let polkadot_future =
+		polkadot_collator::start_collator(builder, id, key, polkadot_config).map(|_| ());
+	service.task_manager.spawn_essential_handle().spawn("polkadot", polkadot_future);
+
+	Ok(service.task_manager)
 }

cumulus/test/parachain/tests/integration_test.rs

@@ -24,8 +24,8 @@ use futures::{future::FutureExt, join, pin_mut, select};
 use jsonrpsee::{raw::RawClient, transport::http::HttpTransportClient};
 use polkadot_primitives::parachain::{Info, Scheduling};
 use polkadot_primitives::Hash as PHash;
-use polkadot_runtime::{Header, Runtime, SignedExtra, SignedPayload, IsCallable};
-use polkadot_runtime_common::{parachains, registrar, BlockHashCount, claims, TransactionCallFilter};
+use polkadot_runtime::{Header, Runtime, SignedExtra, SignedPayload};
+use polkadot_runtime_common::{parachains, registrar, BlockHashCount, claims};
 use serde_json::Value;
 use sp_arithmetic::traits::SaturatedConversion;
 use sp_runtime::generic;