Bounded Validators / Authorities in New Sessions

bin/node-template/runtime/src/lib.rs

@@ -201,8 +201,13 @@ impl frame_system::Config for Runtime {
 	type OnSetCode = ();
 }
 
+parameter_types! {
+	pub const MaxAuthorities: u32 = 100;
+}
+
 impl pallet_aura::Config for Runtime {
 	type AuthorityId = AuraId;
+	type MaxAuthorities = MaxAuthorities;
 }
 
 impl pallet_grandpa::Config for Runtime {
@@ -221,6 +226,8 @@ impl pallet_grandpa::Config for Runtime {
 
 	type HandleEquivocation = ();
 
+	type MaxAuthorities = MaxAuthorities;
+
 	type WeightInfo = ();
 }
 
@@ -394,7 +401,7 @@ impl_runtime_apis! {
 		}
 
 		fn authorities() -> Vec<AuraId> {
-			Aura::authorities()
+			Aura::authorities().to_vec()
 		}
 	}
 

bin/node/runtime/src/lib.rs

@@ -332,8 +332,14 @@ parameter_types! {
 	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
 	pub const ReportLongevity: u64 =
 		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
+	// The maximum number of authorities / validators for this runtime system.
+	// This is should be shared across all pallets using session handlers.
+	pub const MaxAuthorities: u32 = 100;
 }
 
+// Just a convenient rename...
+type MaxValidators = MaxAuthorities;
+
 impl pallet_babe::Config for Runtime {
 	type EpochDuration = EpochDuration;
 	type ExpectedBlockTime = ExpectedBlockTime;
@@ -354,6 +360,8 @@ impl pallet_babe::Config for Runtime {
 	type HandleEquivocation =
 		pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
 
+	type MaxAuthorities = MaxAuthorities;
+
 	type WeightInfo = ();
 }
 
@@ -446,6 +454,7 @@ impl pallet_session::Config for Runtime {
 	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
 	type Keys = SessionKeys;
 	type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
+	type MaxValidators = MaxValidators;
 	type WeightInfo = pallet_session::weights::SubstrateWeight<Runtime>;
 }
 
@@ -496,6 +505,7 @@ impl pallet_staking::Config for Runtime {
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type ElectionProvider = ElectionProviderMultiPhase;
+	type MaxValidators = MaxValidators;
 	type WeightInfo = pallet_staking::weights::SubstrateWeight<Runtime>;
 }
 
@@ -891,6 +901,7 @@ impl pallet_im_online::Config for Runtime {
 	type ValidatorSet = Historical;
 	type ReportUnresponsiveness = Offences;
 	type UnsignedPriority = ImOnlineUnsignedPriority;
+	type MaxAuthorityKeys = MaxAuthorities;
 	type WeightInfo = pallet_im_online::weights::SubstrateWeight<Runtime>;
 }
 
@@ -925,6 +936,8 @@ impl pallet_grandpa::Config for Runtime {
 	type HandleEquivocation =
 		pallet_grandpa::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;
 
+	type MaxAuthorities = MaxAuthorities;
+
 	type WeightInfo = ();
 }
 
@@ -1294,7 +1307,7 @@ impl_runtime_apis! {
 				slot_duration: Babe::slot_duration(),
 				epoch_length: EpochDuration::get(),
 				c: BABE_GENESIS_EPOCH_CONFIG.c,
-				genesis_authorities: Babe::authorities(),
+				genesis_authorities: Babe::authorities().to_vec(),
 				randomness: Babe::randomness(),
 				allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots,
 			}

frame/aura/src/lib.rs

@@ -37,10 +37,14 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use sp_std::prelude::*;
+use sp_std::{
+	prelude::*,
+	convert::TryInto,
+};
 use codec::{Encode, Decode};
 use frame_support::{
-	Parameter, traits::{Get, FindAuthor, OneSessionHandler, OnTimestampSet}, ConsensusEngineId,
+	Parameter, BoundedVec, ConsensusEngineId,
+	traits::{Get, FindAuthor, OneSessionHandler, OnTimestampSet},
 };
 use sp_runtime::{
 	RuntimeAppPublic,
@@ -64,11 +68,21 @@ pub mod pallet {
 	pub trait Config: pallet_timestamp::Config + frame_system::Config {
 		/// The identifier type for an authority.
 		type AuthorityId: Member + Parameter + RuntimeAppPublic + Default + MaybeSerializeDeserialize;
+
+		/// The maximum number of authorities that can be registered in this pallet.
+		type MaxAuthorities: Get<u32>;
 	}
 
 	#[pallet::pallet]
 	pub struct Pallet<T>(sp_std::marker::PhantomData<T>);
 
+	// Errors inform users that something went wrong.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// You are trying to add more authorities than allowed in the pallet configuration.
+		TooManyAuthorities,
+	}
+
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(_: T::BlockNumber) -> Weight {
@@ -93,7 +107,11 @@ pub mod pallet {
 	/// The current authority set.
 	#[pallet::storage]
 	#[pallet::getter(fn authorities)]
-	pub(super) type Authorities<T: Config> = StorageValue<_, Vec<T::AuthorityId>, ValueQuery>;
+	pub(super) type Authorities<T: Config> = StorageValue<
+		_,
+		BoundedVec<T::AuthorityId, T::MaxAuthorities>,
+		ValueQuery,
+	>;
 
 	/// The current slot of this block.
 	///
@@ -123,20 +141,24 @@ pub mod pallet {
 }
 
 impl<T: Config> Pallet<T> {
-	fn change_authorities(new: Vec<T::AuthorityId>) {
+	fn change_authorities(new: BoundedVec<T::AuthorityId, T::MaxAuthorities>) {
 		<Authorities<T>>::put(&new);
 
 		let log: DigestItem<T::Hash> = DigestItem::Consensus(
 			AURA_ENGINE_ID,
-			ConsensusLog::AuthoritiesChange(new).encode()
+			ConsensusLog::AuthoritiesChange(new.to_vec()).encode()
 		);
 		<frame_system::Pallet<T>>::deposit_log(log.into());
 	}
 
 	fn initialize_authorities(authorities: &[T::AuthorityId]) {
 		if !authorities.is_empty() {
 			assert!(<Authorities<T>>::get().is_empty(), "Authorities are already initialized!");
-			<Authorities<T>>::put(authorities);
+			let bounded_authorities: BoundedVec<T::AuthorityId, T::MaxAuthorities> = authorities
+				.to_vec()
+				.try_into()
+				.expect("Too many initial authorities!");
+			<Authorities<T>>::put(&bounded_authorities);
 		}
 	}
 
@@ -165,7 +187,7 @@ impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
 	type Public = T::AuthorityId;
 }
 
-impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
+impl<T: Config> OneSessionHandler<T::AccountId, T::MaxAuthorities> for Pallet<T> {
 	type Key = T::AuthorityId;
 
 	fn on_genesis_session<'a, I: 'a>(validators: I)
@@ -181,9 +203,15 @@ impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
 		// instant changes
 		if changed {
 			let next_authorities = validators.map(|(_, k)| k).collect::<Vec<_>>();
+			// Truncate any extra that would not fit into storage...
+			let bounded_next_authorities = BoundedVec::<T::AuthorityId, T::MaxAuthorities>::truncating_from(
+				next_authorities,
+				Some("Aura New Session"),
+			);
+
 			let last_authorities = Self::authorities();
-			if next_authorities != last_authorities {
-				Self::change_authorities(next_authorities);
+			if bounded_next_authorities != last_authorities {
+				Self::change_authorities(bounded_next_authorities);
 			}
 		}
 	}

frame/aura/src/mock.rs

@@ -80,8 +80,13 @@ impl pallet_timestamp::Config for Test {
 	type WeightInfo = ();
 }
 
+parameter_types! {
+	pub const MaxAuthorities: u32 = 10;
+}
+
 impl pallet_aura::Config for Test {
 	type AuthorityId = AuthorityId;
+	type MaxAuthorities = MaxAuthorities;
 }
 
 pub fn new_test_ext(authorities: Vec<u64>) -> sp_io::TestExternalities {

frame/aura/src/tests.rs

@@ -20,6 +20,8 @@
 #![cfg(test)]
 
 use crate::mock::{Aura, new_test_ext};
+use sp_runtime::testing::UintAuthorityId;
+use frame_support::traits::OneSessionHandler;
 
 #[test]
 fn initial_values() {
@@ -28,3 +30,30 @@ fn initial_values() {
 		assert_eq!(Aura::authorities().len(), 4);
 	});
 }
+
+// Should not be able to put more authorities than allowed in genesis.
+#[test]
+#[should_panic(expected = "Too many initial authorities!")]
+fn too_many_initial_fails() {
+	new_test_ext((0..100).collect::<Vec<_>>());
+}
+
+// Session change should truncate the new authorities to fit into the limits
+// of the Aura pallet.
+#[test]
+fn session_change_truncates() {
+	new_test_ext(vec![0, 1, 2, 3]).execute_with(|| {
+		Aura::on_new_session(
+			true,
+			(0..100)
+				.map(|x| {
+					let auth_id = UintAuthorityId(x).to_public_key();
+					(&0, auth_id)
+				})
+				.collect::<Vec<_>>()
+				.into_iter(),
+			vec![].into_iter(),
+		);
+		assert_eq!(Aura::authorities().len(), 10);
+	});
+}

frame/authority-discovery/src/lib.rs

@@ -23,8 +23,8 @@
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use sp_std::prelude::*;
-use frame_support::traits::OneSessionHandler;
+use sp_std::{prelude::*, convert::TryInto};
+use frame_support::{traits::OneSessionHandler, BoundedVec};
 #[cfg(feature = "std")]
 use frame_support::traits::GenesisBuild;
 use sp_authority_discovery::AuthorityId;
@@ -50,16 +50,16 @@ pub mod pallet {
 	/// Keys of the current authority set.
 	pub(super) type Keys<T: Config> = StorageValue<
 		_,
-		Vec<AuthorityId>,
+		BoundedVec<AuthorityId, T::MaxValidators>,
 		ValueQuery,
 	>;
-	
+
 	#[pallet::storage]
 	#[pallet::getter(fn next_keys)]
 	/// Keys of the next authority set.
 	pub(super) type NextKeys<T: Config> = StorageValue<
 		_,
-		Vec<AuthorityId>,
+		BoundedVec<AuthorityId, T::MaxValidators>,
 		ValueQuery,
 	>;
 
@@ -79,7 +79,9 @@ pub mod pallet {
 	#[pallet::genesis_build]
 	impl<T: Config> GenesisBuild<T> for GenesisConfig {
 		fn build(&self) {
-			Pallet::<T>::initialize_keys(&self.keys)
+			let bounded_keys: BoundedVec::<AuthorityId, T::MaxValidators> =
+				self.keys.clone().try_into().expect("Too many genesis keys!");
+			Pallet::<T>::initialize_keys(&bounded_keys)
 		}
 	}
 
@@ -94,8 +96,8 @@ impl<T: Config> Pallet<T> {
 	/// Retrieve authority identifiers of the current and next authority set
 	/// sorted and deduplicated.
 	pub fn authorities() -> Vec<AuthorityId> {
-		let mut keys = Keys::<T>::get();
-		let next = NextKeys::<T>::get();
+		let mut keys = Keys::<T>::get().to_vec();
+		let next = NextKeys::<T>::get().to_vec();
 
 		keys.extend(next);
 		keys.sort();
@@ -106,19 +108,21 @@ impl<T: Config> Pallet<T> {
 
 	/// Retrieve authority identifiers of the current authority set in the original order.
 	pub fn current_authorities() -> Vec<AuthorityId> {
-		Keys::<T>::get()
+		Keys::<T>::get().to_vec()
 	}
 
 	/// Retrieve authority identifiers of the next authority set in the original order.
 	pub fn next_authorities() -> Vec<AuthorityId> {
-		NextKeys::<T>::get()
+		NextKeys::<T>::get().to_vec()
 	}
 
 	fn initialize_keys(keys: &[AuthorityId]) {
 		if !keys.is_empty() {
 			assert!(Keys::<T>::get().is_empty(), "Keys are already initialized!");
-			Keys::<T>::put(keys);
-			NextKeys::<T>::put(keys);
+			let bounded_keys: BoundedVec<AuthorityId, T::MaxValidators> =
+				keys.to_vec().try_into().expect("Too many initial keys!");
+			Keys::<T>::put(&bounded_keys);
+			NextKeys::<T>::put(&bounded_keys);
 		}
 	}
 }
@@ -127,7 +131,7 @@ impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
 	type Public = AuthorityId;
 }
 
-impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
+impl<T: Config> OneSessionHandler<T::AccountId, T::MaxValidators> for Pallet<T> {
 	type Key = AuthorityId;
 
 	fn on_genesis_session<'a, I: 'a>(authorities: I)
@@ -143,10 +147,20 @@ impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
 	{
 		// Remember who the authorities are for the new and next session.
 		if changed {
-			let keys = validators.map(|x| x.1);
-			Keys::<T>::put(keys.collect::<Vec<_>>());
-			let next_keys = queued_validators.map(|x| x.1);
-			NextKeys::<T>::put(next_keys.collect::<Vec<_>>());
+			let keys = validators.map(|x| x.1).collect::<Vec<_>>();
+			// Truncate any extra that would not fit in storage...
+			let bounded_keys = BoundedVec::<AuthorityId, T::MaxValidators>::truncating_from(
+				keys,
+				Some("Authority Discovery New Session Keys"),
+			);
+			Keys::<T>::put(bounded_keys);
+			let next_keys = queued_validators.map(|x| x.1).collect::<Vec<_>>();
+			// Truncate any extra that would not fit in storage...
+			let bounded_next_keys = BoundedVec::<AuthorityId, T::MaxValidators>::truncating_from(
+				next_keys,
+				Some("Authority Discovery New Session Next Keys"),
+			);
+			NextKeys::<T>::put(bounded_next_keys);
 		}
 	}
 
@@ -211,6 +225,7 @@ mod tests {
 		type ValidatorIdOf = ConvertInto;
 		type DisabledValidatorsThreshold = DisabledValidatorsThreshold;
 		type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+		type MaxValidators = MaxValidators;
 		type WeightInfo = ();
 	}
 
@@ -256,8 +271,12 @@ mod tests {
 		type OnSetCode = ();
 	}
 
+	parameter_types! {
+		pub const MaxValidators: u32 = 10;
+	}
+
 	pub struct TestSessionHandler;
-	impl pallet_session::SessionHandler<AuthorityId> for TestSessionHandler {
+	impl pallet_session::SessionHandler<AuthorityId, MaxValidators> for TestSessionHandler {
 		const KEY_TYPE_IDS: &'static [KeyTypeId] = &[key_types::DUMMY];
 
 		fn on_new_session<Ks: OpaqueKeys>(