Switch to latest Substrate & Polkadot

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)
 		})
 	}
 }

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

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);

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

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" }

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! {

test/parachain/src/command.rs

@@ -17,22 +17,21 @@
 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::{
 	traits::{Block as BlockT, Hash as HashT, Header as HeaderT, Zero},
 	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"));
-
-					let task_executor = config.task_executor.clone();
-					let polkadot_config = SubstrateCli::create_configuration(
-						&polkadot_cli,
-						&polkadot_cli,
-						task_executor,
-					)
-					.unwrap();
-
-					info!("Parachain id: {:?}", id);
-					info!("Parachain Account: {}", parachain_account);
-					info!("Parachain genesis state: {}", genesis_state);
-
-					crate::service::run_collator(config, key, polkadot_config, id)
-				},
-				parachain_runtime::VERSION,
-			)
+			runner.run_node_until_exit(|config| {
+				if matches!(config.role, Role::Light) {
+					return Err("Light client not supporter!".into());
+				}
+
+				polkadot_cli.base_path =
+					config.base_path.as_ref().map(|x| x.path().join("polkadot"));
+
+				let task_executor = config.task_executor.clone();
+				let polkadot_config =
+					SubstrateCli::create_configuration(&polkadot_cli, &polkadot_cli, task_executor)
+						.unwrap();
+
+				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>> {