Merge branch 'master' of github.com:paritytech/substrate into kiz-fix-reward-pools-2

Author: kianenigma

Cargo.lock

@@ -47,7 +47,6 @@ use frame_system::{
 };
 pub use node_primitives::{AccountId, Signature};
 use node_primitives::{AccountIndex, Balance, BlockNumber, Hash, Index, Moment};
-use pallet_contracts::weights::WeightInfo;
 use pallet_election_provider_multi_phase::SolutionAccuracyOf;
 use pallet_grandpa::{
 	fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList,
@@ -1118,18 +1117,13 @@ parameter_types! {
 	pub const DepositPerItem: Balance = deposit(1, 0);
 	pub const DepositPerByte: Balance = deposit(0, 1);
 	pub const MaxValueSize: u32 = 16 * 1024;
+	pub const DeletionQueueDepth: u32 = 128;
 	// The lazy deletion runs inside on_initialize.
 	pub DeletionWeightLimit: Weight = RuntimeBlockWeights::get()
 		.per_class
 		.get(DispatchClass::Normal)
 		.max_total
 		.unwrap_or(RuntimeBlockWeights::get().max_block);
-	// The weight needed for decoding the queue should be less or equal than a fifth
-	// of the overall weight dedicated to the lazy deletion.
-	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (
-			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -
-			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)
-		)) / 5) as u32;
 	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
 }
 

bin/node/runtime/src/lib.rs

@@ -1873,7 +1873,11 @@ where
 {
 	let best_number = client.info().best_number;
 	let finalized = client.info().finalized_number;
+
 	let revertible = blocks.min(best_number - finalized);
+	if revertible == Zero::zero() {
+		return Ok(())
+	}
 
 	let revert_up_to_number = best_number - revertible;
 	let revert_up_to_hash = client.hash(revert_up_to_number)?.ok_or(ClientError::Backend(

client/consensus/babe/src/lib.rs

@@ -755,7 +755,10 @@ where
 					Err(e) => PersistedEpoch::Regular(e),
 				}
 			}
-		} else if epoch.is_genesis() && !self.epochs.values().all(|e| e.is_genesis()) {
+		} else if epoch.is_genesis() &&
+			!self.epochs.is_empty() &&
+			!self.epochs.values().any(|e| e.is_genesis())
+		{
 			// There's a genesis epoch imported when we already have an active epoch.
 			// This happens after the warp sync as the ancient blocks download start.
 			// We need to start tracking gap epochs here.
@@ -1170,15 +1173,17 @@ mod tests {
 		epoch_changes.clear_gap();
 
 		// Check that both epochs are available.
-		epoch_changes
+		let epoch_a = epoch_changes
 			.epoch_data_for_child_of(&is_descendent_of, b"A", 1, 101, &make_genesis)
 			.unwrap()
 			.unwrap();
 
-		epoch_changes
+		let epoch_x = epoch_changes
 			.epoch_data_for_child_of(&is_descendent_of, b"X", 1, 1001, &make_genesis)
 			.unwrap()
 			.unwrap();
+
+		assert!(epoch_a != epoch_x)
 	}
 
 	#[test]
@@ -1288,4 +1293,108 @@ mod tests {
 		epoch_changes.clear_gap();
 		assert!(epoch_changes.gap.is_none());
 	}
+
+	/// Test that ensures that the gap is not enabled when there's still genesis
+	/// epochs imported, regardless of whether there are already other further
+	/// epochs imported descending from such genesis epochs.
+	#[test]
+	fn gap_is_not_enabled_when_at_least_one_genesis_epoch_is_still_imported() {
+		//     A (#1) - B (#201)
+		//   /
+		// 0 - C (#1)
+		//
+		// The epoch duration is 100 slots, each of these blocks represents
+		// an epoch change block. block B starts a new epoch at #201 since the
+		// genesis epoch spans two epochs.
+
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (base, block) {
+				(b"0", _) => Ok(true),
+				(b"A", b"B") => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		let duration = 100;
+		let make_genesis = |slot| Epoch { start_slot: slot, duration };
+		let mut epoch_changes = EpochChanges::new();
+		let next_descriptor = ();
+
+		// insert genesis epoch for A at slot 1
+		{
+			let genesis_epoch_a_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 1)
+				.unwrap()
+				.unwrap();
+
+			let incremented_epoch = epoch_changes
+				.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
+				.unwrap()
+				.increment(next_descriptor.clone());
+
+			epoch_changes
+				.import(&is_descendent_of, *b"A", 1, *b"0", incremented_epoch)
+				.unwrap();
+		}
+
+		// insert regular epoch for B at slot 201, descending from A
+		{
+			let epoch_b_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, b"A", 1, 201)
+				.unwrap()
+				.unwrap();
+
+			let incremented_epoch = epoch_changes
+				.viable_epoch(&epoch_b_descriptor, &make_genesis)
+				.unwrap()
+				.increment(next_descriptor.clone());
+
+			epoch_changes
+				.import(&is_descendent_of, *b"B", 201, *b"A", incremented_epoch)
+				.unwrap();
+		}
+
+		// insert genesis epoch for C at slot 1000
+		{
+			let genesis_epoch_x_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 1000)
+				.unwrap()
+				.unwrap();
+
+			let incremented_epoch = epoch_changes
+				.viable_epoch(&genesis_epoch_x_descriptor, &make_genesis)
+				.unwrap()
+				.increment(next_descriptor.clone());
+
+			epoch_changes
+				.import(&is_descendent_of, *b"C", 1, *b"0", incremented_epoch)
+				.unwrap();
+		}
+
+		// Clearing the gap should be a no-op.
+		epoch_changes.clear_gap();
+
+		// Check that all three epochs are available.
+		let epoch_a = epoch_changes
+			.epoch_data_for_child_of(&is_descendent_of, b"A", 1, 10, &make_genesis)
+			.unwrap()
+			.unwrap();
+
+		let epoch_b = epoch_changes
+			.epoch_data_for_child_of(&is_descendent_of, b"B", 201, 201, &make_genesis)
+			.unwrap()
+			.unwrap();
+
+		assert!(epoch_a != epoch_b);
+
+		// the genesis epoch A will span slots [1, 200] with epoch B starting at slot 201
+		assert_eq!(epoch_b.start_slot(), 201);
+
+		let epoch_c = epoch_changes
+			.epoch_data_for_child_of(&is_descendent_of, b"C", 1, 1001, &make_genesis)
+			.unwrap()
+			.unwrap();
+
+		assert!(epoch_a != epoch_c);
+	}
 }

client/consensus/epochs/src/lib.rs

@@ -1170,11 +1170,15 @@ fn local_authority_id(
 pub fn revert<Block, Client>(client: Arc<Client>, blocks: NumberFor<Block>) -> ClientResult<()>
 where
 	Block: BlockT,
-	Client: AuxStore + HeaderMetadata<Block, Error = sp_blockchain::Error> + HeaderBackend<Block>,
+	Client: AuxStore + HeaderMetadata<Block, Error = ClientError> + HeaderBackend<Block>,
 {
 	let best_number = client.info().best_number;
 	let finalized = client.info().finalized_number;
+
 	let revertible = blocks.min(best_number - finalized);
+	if revertible == Zero::zero() {
+		return Ok(())
+	}
 
 	let number = best_number - revertible;
 	let hash = client
@@ -1185,8 +1189,12 @@ where
 		)))?;
 
 	let info = client.info();
+
 	let persistent_data: PersistentData<Block> =
-		aux_schema::load_persistent(&*client, info.genesis_hash, Zero::zero(), || unreachable!())?;
+		aux_schema::load_persistent(&*client, info.genesis_hash, Zero::zero(), || {
+			const MSG: &str = "Unexpected missing grandpa data during revert";
+			Err(ClientError::Application(Box::from(MSG)))
+		})?;
 
 	let shared_authority_set = persistent_data.authority_set;
 	let mut authority_set = shared_authority_set.inner();

client/finality-grandpa/src/lib.rs

@@ -13,6 +13,9 @@ hex = { version = "0.4", default-features = false, optional = true }
 log = { version = "0.4", default-features = false, optional = true }
 tiny-keccak = { version = "2.0.2", features = ["keccak"], optional = true }
 
+beefy-primitives = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/beefy" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+
 [dev-dependencies]
 env_logger = "0.9"
 hex = "0.4"
@@ -22,4 +25,7 @@ hex-literal = "0.3"
 debug = ["hex", "hex/std", "log"]
 default = ["debug", "keccak", "std"]
 keccak = ["tiny-keccak"]
-std = []
+std = [
+	"beefy-primitives/std",
+	"sp-api/std"
+]

frame/beefy-mmr/primitives/Cargo.toml

@@ -36,6 +36,8 @@ extern crate alloc;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
+use beefy_primitives::mmr::{BeefyAuthoritySet, BeefyNextAuthoritySet};
+
 /// Supported hashing output size.
 ///
 /// The size is restricted to 32 bytes to allow for a more optimised implementation.
@@ -375,6 +377,21 @@ where
 	}
 }
 
+sp_api::decl_runtime_apis! {
+	/// API useful for BEEFY light clients.
+	pub trait BeefyMmrApi<H>
+	where
+		H: From<Hash> + Into<Hash>,
+		BeefyAuthoritySet<H>: sp_api::Decode,
+	{
+		/// Return the currently active BEEFY authority set proof.
+		fn authority_set_proof() -> BeefyAuthoritySet<H>;
+
+		/// Return the next/queued BEEFY authority set proof.
+		fn next_authority_set_proof() -> BeefyNextAuthoritySet<H>;
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;

frame/beefy-mmr/primitives/src/lib.rs

@@ -36,7 +36,10 @@
 use sp_runtime::traits::{Convert, Hash, Member};
 use sp_std::prelude::*;
 
-use beefy_primitives::mmr::{BeefyDataProvider, BeefyNextAuthoritySet, MmrLeaf, MmrLeafVersion};
+use beefy_primitives::{
+	mmr::{BeefyAuthoritySet, BeefyDataProvider, BeefyNextAuthoritySet, MmrLeaf, MmrLeafVersion},
+	ValidatorSet as BeefyValidatorSet,
+};
 use pallet_mmr::{LeafDataProvider, ParentNumberAndHash};
 
 use frame_support::{crypto::ecdsa::ECDSAExt, traits::Get};
@@ -124,6 +127,12 @@ pub mod pallet {
 		type BeefyDataProvider: BeefyDataProvider<Self::LeafExtra>;
 	}
 
+	/// Details of current BEEFY authority set.
+	#[pallet::storage]
+	#[pallet::getter(fn beefy_authorities)]
+	pub type BeefyAuthorities<T: Config> =
+		StorageValue<_, BeefyAuthoritySet<MerkleRootOf<T>>, ValueQuery>;
+
 	/// Details of next BEEFY authority set.
 	///
 	/// This storage entry is used as cache for calls to `update_beefy_next_authority_set`.
@@ -149,7 +158,7 @@ where
 			version: T::LeafVersion::get(),
 			parent_number_and_hash: ParentNumberAndHash::<T>::leaf_data(),
 			leaf_extra: T::BeefyDataProvider::extra_data(),
-			beefy_next_authority_set: Pallet::<T>::update_beefy_next_authority_set(),
+			beefy_next_authority_set: Pallet::<T>::beefy_next_authorities(),
 		}
 	}
 }
@@ -163,35 +172,55 @@ where
 	}
 }
 
+impl<T> beefy_primitives::OnNewValidatorSet<<T as pallet_beefy::Config>::BeefyId> for Pallet<T>
+where
+	T: pallet::Config,
+	MerkleRootOf<T>: From<beefy_merkle_tree::Hash> + Into<beefy_merkle_tree::Hash>,
+{
+	/// Compute and cache BEEFY authority sets based on updated BEEFY validator sets.
+	fn on_new_validator_set(
+		current_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+		next_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+	) {
+		let current = Pallet::<T>::compute_authority_set(current_set);
+		let next = Pallet::<T>::compute_authority_set(next_set);
+		// cache the result
+		BeefyAuthorities::<T>::put(&current);
+		BeefyNextAuthorities::<T>::put(&next);
+	}
+}
+
 impl<T: Config> Pallet<T>
 where
 	MerkleRootOf<T>: From<beefy_merkle_tree::Hash> + Into<beefy_merkle_tree::Hash>,
 {
-	/// Returns details of the next BEEFY authority set.
+	/// Return the currently active BEEFY authority set proof.
+	pub fn authority_set_proof() -> BeefyAuthoritySet<MerkleRootOf<T>> {
+		Pallet::<T>::beefy_authorities()
+	}
+
+	/// Return the next/queued BEEFY authority set proof.
+	pub fn next_authority_set_proof() -> BeefyNextAuthoritySet<MerkleRootOf<T>> {
+		Pallet::<T>::beefy_next_authorities()
+	}
+
+	/// Returns details of a BEEFY authority set.
 	///
 	/// Details contain authority set id, authority set length and a merkle root,
 	/// constructed from uncompressed secp256k1 public keys converted to Ethereum addresses
 	/// of the next BEEFY authority set.
-	///
-	/// This function will use a storage-cached entry in case the set didn't change, or compute and
-	/// cache new one in case it did.
-	fn update_beefy_next_authority_set() -> BeefyNextAuthoritySet<MerkleRootOf<T>> {
-		let id = pallet_beefy::Pallet::<T>::validator_set_id() + 1;
-		let current_next = Self::beefy_next_authorities();
-		// avoid computing the merkle tree if validator set id didn't change.
-		if id == current_next.id {
-			return current_next
-		}
-
-		let beefy_addresses = pallet_beefy::Pallet::<T>::next_authorities()
+	fn compute_authority_set(
+		validator_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+	) -> BeefyAuthoritySet<MerkleRootOf<T>> {
+		let id = validator_set.id();
+		let beefy_addresses = validator_set
+			.validators()
 			.into_iter()
+			.cloned()
 			.map(T::BeefyAuthorityToMerkleLeaf::convert)
 			.collect::<Vec<_>>();
 		let len = beefy_addresses.len() as u32;
 		let root = beefy_merkle_tree::merkle_root::<Self, _, _>(beefy_addresses).into();
-		let next_set = BeefyNextAuthoritySet { id, len, root };
-		// cache the result
-		BeefyNextAuthorities::<T>::put(&next_set);
-		next_set
+		BeefyAuthoritySet { id, len, root }
 	}
 }

frame/beefy-mmr/src/lib.rs

@@ -125,6 +125,7 @@ impl pallet_mmr::Config for Test {
 impl pallet_beefy::Config for Test {
 	type BeefyId = BeefyId;
 	type MaxAuthorities = ConstU32<100>;
+	type OnNewValidatorSet = BeefyMmr;
 }
 
 parameter_types! {