Merge branch 'master' into nv-assign-db-weights

Author: NikVolf

Cargo.lock

@@ -83,12 +83,12 @@ pub trait Network: Send + Sync {
 	/// The returned stream will not terminate, so it is required to make sure that the stream is
 	/// dropped when it is not required anymore. Otherwise, it will stick around in memory
 	/// infinitely.
-	fn checked_statements(&self, relay_parent: Hash) -> Pin<Box<dyn Stream<Item=SignedStatement>>>;
+	fn checked_statements(&self, relay_parent: Hash) -> Pin<Box<dyn Stream<Item=SignedStatement> + Send>>;
 }
 
 impl Network for polkadot_network::protocol::Service {
-	fn checked_statements(&self, relay_parent: Hash) -> Pin<Box<dyn Stream<Item=SignedStatement>>> {
-		polkadot_network::protocol::Service::checked_statements(self, relay_parent)
+	fn checked_statements(&self, relay_parent: Hash) -> Pin<Box<dyn Stream<Item=SignedStatement> + Send>> {
+		polkadot_network::protocol::Service::checked_statements(self, relay_parent).boxed()
 	}
 }
 
@@ -241,12 +241,14 @@ fn build_collator_service<S, P, Extrinsic>(
 	let (service, handles) = service;
 	let spawner = service.spawn_task_handle();
 
-	let polkadot_network = match handles.polkadot_network {
-		None => return Err(
-			"Collator cannot run when Polkadot-specific networking has not been started".into()
-		),
-		Some(n) => n,
-	};
+	let polkadot_network = handles.polkadot_network
+		.ok_or_else(|| "Collator cannot run when Polkadot-specific networking has not been started")?;
+
+	// We don't require this here, but we need to make sure that the validation service is started.
+	// This service makes sure the collator is joining the correct gossip topics and receives the appropiate
+	// messages.
+	handles.validation_service_handle
+		.ok_or_else(|| "Collator cannot run when validation networking has not been started")?;
 
 	let client = service.client();
 

collator/src/lib.rs

@@ -1375,7 +1375,7 @@ impl<N: NetworkServiceOps> Service<N> {
 	/// Take care to drop the stream, as the sending side will not be cleaned
 	/// up until it is.
 	pub fn checked_statements(&self, relay_parent: Hash)
-		-> Pin<Box<dyn Stream<Item = SignedStatement>>> {
+		-> impl Stream<Item = SignedStatement> + Send {
 		let (tx, rx) = oneshot::channel();
 		let mut sender = self.sender.clone();
 
@@ -1400,7 +1400,6 @@ impl<N: NetworkServiceOps> Service<N> {
 				}
 			})
 			.flatten_stream()
-			.boxed()
 	}
 }
 

network/src/protocol/mod.rs

@@ -19,5 +19,4 @@ sp-blockchain = { git = "https://github.com/paritytech/substrate", branch = "mas
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sc-block-builder = { git = "https://github.com/paritytech/substrate", branch = "master" }
-env_logger = "0.7.0"
 polkadot-test-runtime-client = { path = "../../runtime/test-runtime/client" }

network/test/Cargo.toml

@@ -27,7 +27,15 @@ use super::*;
 
 fn prepare_good_block() -> (TestClient, Hash, u64, PeerId, IncomingBlock<Block>) {
 	let mut client = polkadot_test_runtime_client::new();
-	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let mut builder = client.new_block(Default::default()).unwrap();
+
+	let extrinsics = polkadot_test_runtime_client::needed_extrinsics(vec![]);
+
+	for extrinsic in &extrinsics {
+		builder.push(extrinsic.clone()).unwrap();
+	}
+
+	let block = builder.build().unwrap().block;
 	client.import(BlockOrigin::File, block).unwrap();
 
 	let (hash, number) = (client.block_hash(1).unwrap().unwrap(), 1);
@@ -37,7 +45,7 @@ fn prepare_good_block() -> (TestClient, Hash, u64, PeerId, IncomingBlock<Block>)
 	(client, hash, number, peer_id.clone(), IncomingBlock {
 		hash,
 		header,
-		body: Some(Vec::new()),
+		body: Some(extrinsics),
 		justification,
 		origin: Some(peer_id.clone()),
 		allow_missing_state: false,

network/test/src/block_import.rs

@@ -23,9 +23,10 @@
 use std::any::{TypeId, Any};
 use crate::primitives::{ValidationParams, ValidationResult, UpwardMessage};
 use codec::{Decode, Encode};
-use sp_core::storage::{ChildStorageKey, ChildInfo};
+use sp_core::storage::ChildInfo;
 use sp_core::traits::CallInWasm;
 use sp_wasm_interface::HostFunctions as _;
+use sp_externalities::Extensions;
 
 #[cfg(not(target_os = "unknown"))]
 pub use validation_host::{run_worker, ValidationPool, EXECUTION_TIMEOUT_SEC};
@@ -171,7 +172,11 @@ pub fn validate_candidate_internal<E: Externalities + 'static>(
 	encoded_call_data: &[u8],
 	externalities: E,
 ) -> Result<ValidationResult, Error> {
-	let mut ext = ValidationExternalities(ParachainExt::new(externalities));
+	let mut extensions = Extensions::new();
+	extensions.register(ParachainExt::new(externalities));
+	extensions.register(sp_core::traits::TaskExecutorExt(sp_core::tasks::executor()));
+
+	let mut ext = ValidationExternalities(extensions);
 
 	let executor = sc_executor::WasmExecutor::new(
 		sc_executor::WasmExecutionMethod::Interpreted,
@@ -194,7 +199,7 @@ pub fn validate_candidate_internal<E: Externalities + 'static>(
 
 /// The validation externalities that will panic on any storage related access. They just provide
 /// access to the parachain extension.
-struct ValidationExternalities(ParachainExt);
+struct ValidationExternalities(Extensions);
 
 impl sp_externalities::Externalities for ValidationExternalities {
 	fn storage(&self, _: &[u8]) -> Option<Vec<u8>> {
@@ -205,31 +210,31 @@ impl sp_externalities::Externalities for ValidationExternalities {
 		panic!("storage_hash: unsupported feature for parachain validation")
 	}
 
-	fn child_storage_hash(&self, _: ChildStorageKey, _: ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage_hash(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("child_storage_hash: unsupported feature for parachain validation")
 	}
 
-	fn child_storage(&self, _: ChildStorageKey, _: ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("child_storage: unsupported feature for parachain validation")
 	}
 
-	fn kill_child_storage(&mut self, _: ChildStorageKey, _: ChildInfo) {
+	fn kill_child_storage(&mut self, _: &ChildInfo) {
 		panic!("kill_child_storage: unsupported feature for parachain validation")
 	}
 
 	fn clear_prefix(&mut self, _: &[u8]) {
 		panic!("clear_prefix: unsupported feature for parachain validation")
 	}
 
-	fn clear_child_prefix(&mut self, _: ChildStorageKey, _: ChildInfo, _: &[u8]) {
+	fn clear_child_prefix(&mut self, _: &ChildInfo, _: &[u8]) {
 		panic!("clear_child_prefix: unsupported feature for parachain validation")
 	}
 
 	fn place_storage(&mut self, _: Vec<u8>, _: Option<Vec<u8>>) {
 		panic!("place_storage: unsupported feature for parachain validation")
 	}
 
-	fn place_child_storage(&mut self, _: ChildStorageKey, _: ChildInfo, _: Vec<u8>, _: Option<Vec<u8>>) {
+	fn place_child_storage(&mut self, _: &ChildInfo, _: Vec<u8>, _: Option<Vec<u8>>) {
 		panic!("place_child_storage: unsupported feature for parachain validation")
 	}
 
@@ -241,15 +246,15 @@ impl sp_externalities::Externalities for ValidationExternalities {
 		panic!("storage_root: unsupported feature for parachain validation")
 	}
 
-	fn child_storage_root(&mut self, _: ChildStorageKey) -> Vec<u8> {
+	fn child_storage_root(&mut self, _: &ChildInfo) -> Vec<u8> {
 		panic!("child_storage_root: unsupported feature for parachain validation")
 	}
 
 	fn storage_changes_root(&mut self, _: &[u8]) -> Result<Option<Vec<u8>>, ()> {
 		panic!("storage_changes_root: unsupported feature for parachain validation")
 	}
 
-	fn next_child_storage_key(&self, _: ChildStorageKey, _: ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn next_child_storage_key(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("next_child_storage_key: unsupported feature for parachain validation")
 	}
 
@@ -268,25 +273,24 @@ impl sp_externalities::Externalities for ValidationExternalities {
 
 impl sp_externalities::ExtensionStore for ValidationExternalities {
 	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
-		if type_id == TypeId::of::<ParachainExt>() {
-			Some(&mut self.0)
-		} else {
-			None
-		}
+		self.0.get_mut(type_id)
 	}
 
 	fn register_extension_with_type_id(
 		&mut self,
-		_type_id: TypeId,
-		_extension: Box<dyn sp_externalities::Extension>,
+		type_id: TypeId,
+		extension: Box<dyn sp_externalities::Extension>,
 	) -> Result<(), sp_externalities::Error> {
-		panic!("register_extension_with_type_id: unsupported feature for parachain validation")
+		self.0.register_with_type_id(type_id, extension)
 	}
 
 	fn deregister_extension_by_type_id(
 		&mut self,
-		_type_id: TypeId,
+		type_id: TypeId,
 	) -> Result<(), sp_externalities::Error> {
-		panic!("deregister_extension_by_type_id: unsupported feature for parachain validation")
+		match self.0.deregister(type_id) {
+			Some(_) => Ok(()),
+			None => Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
+		}
 	}
 }

parachain/src/wasm_executor/mod.rs

@@ -25,7 +25,7 @@ use frame_support::{
 	decl_storage, decl_module, decl_error, ensure,
 	dispatch::DispatchResult,
 	traits::Get,
-	weights::{MINIMUM_WEIGHT, SimpleDispatchInfo},
+	weights::{MINIMUM_WEIGHT, DispatchClass},
 };
 
 use primitives::{Hash, parachain::{AttestedCandidate, AbridgedCandidateReceipt, Id as ParaId}};
@@ -134,7 +134,7 @@ decl_module! {
 		type Error = Error<T>;
 
 		/// Provide candidate receipts for parachains, in ascending order by id.
-		#[weight = SimpleDispatchInfo::FixedMandatory(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Mandatory)]
 		fn more_attestations(origin, _more: MoreAttestations) -> DispatchResult {
 			ensure_none(origin)?;
 			ensure!(!DidUpdate::exists(), Error::<T>::TooManyAttestations);

runtime/common/src/attestations.rs

@@ -19,7 +19,6 @@
 use sp_std::prelude::*;
 use sp_io::{hashing::keccak_256, crypto::secp256k1_ecdsa_recover};
 use frame_support::{decl_event, decl_storage, decl_module, decl_error};
-use frame_support::weights::SimpleDispatchInfo;
 use frame_support::traits::{Currency, Get, VestingSchedule};
 use system::{ensure_root, ensure_none};
 use codec::{Encode, Decode};
@@ -184,7 +183,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(1)
 		/// </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(1_000_000_000)]
+		#[weight = 1_000_000_000]
 		fn claim(origin, dest: T::AccountId, ethereum_signature: EcdsaSignature) {
 			ensure_none(origin)?;
 
@@ -231,7 +230,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(1)
 		/// </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		fn mint_claim(origin,
 			who: EthereumAddress,
 			value: BalanceOf<T>,

runtime/common/src/claims.rs

@@ -71,7 +71,7 @@ use frame_support::{
 	traits::{
 		Currency, Get, OnUnbalanced, WithdrawReason, ExistenceRequirement::AllowDeath
 	},
-	weights::{MINIMUM_WEIGHT, SimpleDispatchInfo},
+	weights::MINIMUM_WEIGHT,
 };
 use system::ensure_signed;
 use sp_runtime::{ModuleId,
@@ -80,7 +80,6 @@ use sp_runtime::{ModuleId,
 use crate::slots;
 use codec::{Encode, Decode};
 use sp_std::vec::Vec;
-use sp_core::storage::well_known_keys::CHILD_STORAGE_KEY_PREFIX;
 use primitives::parachain::{Id as ParaId, HeadData};
 
 const MODULE_ID: ModuleId = ModuleId(*b"py/cfund");
@@ -251,7 +250,7 @@ decl_module! {
 		fn deposit_event() = default;
 
 		/// Create a new crowdfunding campaign for a parachain slot deposit for the current auction.
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn create(origin,
 			#[compact] cap: BalanceOf<T>,
 			#[compact] first_slot: T::BlockNumber,
@@ -295,7 +294,7 @@ decl_module! {
 		/// Contribute to a crowd sale. This will transfer some balance over to fund a parachain
 		/// slot. It will be withdrawable in two instances: the parachain becomes retired; or the
 		/// slot is unable to be purchased and the timeout expires.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn contribute(origin, #[compact] index: FundIndex, #[compact] value: BalanceOf<T>) {
 			let who = ensure_signed(origin)?;
 
@@ -354,7 +353,7 @@ decl_module! {
 		/// - `index` is the fund index that `origin` owns and whose deploy data will be set.
 		/// - `code_hash` is the hash of the parachain's Wasm validation function.
 		/// - `initial_head_data` is the parachain's initial head data.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn fix_deploy_data(origin,
 			#[compact] index: FundIndex,
 			code_hash: T::Hash,
@@ -380,7 +379,7 @@ decl_module! {
 		///
 		/// - `index` is the fund index that `origin` owns and whose deploy data will be set.
 		/// - `para_id` is the parachain index that this fund won.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn onboard(origin,
 			#[compact] index: FundIndex,
 			#[compact] para_id: ParaId
@@ -409,7 +408,7 @@ decl_module! {
 		}
 
 		/// Note that a successful fund has lost its parachain slot, and place it into retirement.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn begin_retirement(origin, #[compact] index: FundIndex) {
 			let _ = ensure_signed(origin)?;
 
@@ -431,7 +430,7 @@ decl_module! {
 		}
 
 		/// Withdraw full balance of a contributor to an unsuccessful or off-boarded fund.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn withdraw(origin, #[compact] index: FundIndex) {
 			let who = ensure_signed(origin)?;
 
@@ -462,7 +461,7 @@ decl_module! {
 		/// Remove a fund after either: it was unsuccessful and it timed out; or it was successful
 		/// but it has been retired from its parachain slot. This places any deposits that were not
 		/// withdrawn into the treasury.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn dissolve(origin, #[compact] index: FundIndex) {
 			let _ = ensure_signed(origin)?;
 
@@ -529,46 +528,30 @@ impl<T: Trait> Module<T> {
 		MODULE_ID.into_sub_account(index)
 	}
 
-	pub fn id_from_index(index: FundIndex) -> Vec<u8> {
+	pub fn id_from_index(index: FundIndex) -> child::ChildInfo {
 		let mut buf = Vec::new();
 		buf.extend_from_slice(b"crowdfund");
 		buf.extend_from_slice(&index.to_le_bytes()[..]);
-
-		CHILD_STORAGE_KEY_PREFIX.into_iter()
-			.chain(b"default:")
-			.chain(T::Hashing::hash(&buf[..]).as_ref().into_iter())
-			.cloned()
-			.collect()
-	}
-
-	/// Child trie unique id for a crowdfund is built from the hash part of the fund id.
-	pub fn trie_unique_id(fund_id: &[u8]) -> child::ChildInfo {
-		let start = CHILD_STORAGE_KEY_PREFIX.len() + b"default:".len();
-		child::ChildInfo::new_default(&fund_id[start..])
+		child::ChildInfo::new_default(T::Hashing::hash(&buf[..]).as_ref())
 	}
 
 	pub fn contribution_put(index: FundIndex, who: &T::AccountId, balance: &BalanceOf<T>) {
-		let id = Self::id_from_index(index);
-		who.using_encoded(|b| child::put(id.as_ref(), Self::trie_unique_id(id.as_ref()), b, balance));
+		who.using_encoded(|b| child::put(&Self::id_from_index(index), b, balance));
 	}
 
 	pub fn contribution_get(index: FundIndex, who: &T::AccountId) -> BalanceOf<T> {
-		let id = Self::id_from_index(index);
 		who.using_encoded(|b| child::get_or_default::<BalanceOf<T>>(
-			id.as_ref(),
-			Self::trie_unique_id(id.as_ref()),
+			&Self::id_from_index(index),
 			b,
 		))
 	}
 
 	pub fn contribution_kill(index: FundIndex, who: &T::AccountId) {
-		let id = Self::id_from_index(index);
-		who.using_encoded(|b| child::kill(id.as_ref(), Self::trie_unique_id(id.as_ref()), b));
+		who.using_encoded(|b| child::kill(&Self::id_from_index(index), b));
 	}
 
 	pub fn crowdfund_kill(index: FundIndex) {
-		let id = Self::id_from_index(index);
-		child::kill_storage(id.as_ref(), Self::trie_unique_id(id.as_ref()));
+		child::kill_storage(&Self::id_from_index(index));
 	}
 }