Remove Default bound for AccountId

bin/node/runtime/src/impls.rs

@@ -27,7 +27,9 @@ use pallet_asset_tx_payment::HandleCredit;
 pub struct Author;
 impl OnUnbalanced<NegativeImbalance> for Author {
 	fn on_nonzero_unbalanced(amount: NegativeImbalance) {
-		Balances::resolve_creating(&Authorship::author(), amount);
+		if let Some(author) = Authorship::author() {
+			Balances::resolve_creating(&author, amount);
+		}
 	}
 }
 
@@ -36,9 +38,10 @@ impl OnUnbalanced<NegativeImbalance> for Author {
 pub struct CreditToBlockAuthor;
 impl HandleCredit<AccountId, Assets> for CreditToBlockAuthor {
 	fn handle_credit(credit: CreditOf<AccountId, Assets>) {
-		let author = pallet_authorship::Pallet::<Runtime>::author();
-		// Drop the result which will trigger the `OnDrop` of the imbalance in case of error.
-		let _ = Assets::resolve(&author, credit);
+		if let Some(author) = pallet_authorship::Pallet::<Runtime>::author() {
+			// Drop the result which will trigger the `OnDrop` of the imbalance in case of error.
+			let _ = Assets::resolve(&author, credit);
+		}
 	}
 }
 

client/consensus/aura/src/lib.rs

@@ -57,7 +57,7 @@ use sp_consensus::{
 	BlockOrigin, CanAuthorWith, Environment, Error as ConsensusError, Proposer, SelectChain,
 };
 use sp_consensus_slots::Slot;
-use sp_core::crypto::{Pair, Public};
+use sp_core::crypto::{Pair, Public, ByteArray};
 use sp_inherents::CreateInherentDataProviders;
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::{

client/consensus/babe/src/verification.rs

@@ -31,7 +31,7 @@ use sp_consensus_babe::{
 	make_transcript, AuthorityId, AuthorityPair, AuthoritySignature,
 };
 use sp_consensus_slots::Slot;
-use sp_core::{Pair, Public};
+use sp_core::{Pair, Public, ByteArray};
 use sp_runtime::{traits::Header, DigestItem};
 
 /// BABE verification parameters

client/keystore/src/local.rs

@@ -21,7 +21,7 @@ use async_trait::async_trait;
 use parking_lot::RwLock;
 use sp_application_crypto::{ecdsa, ed25519, sr25519, AppKey, AppPair, IsWrappedBy};
 use sp_core::{
-	crypto::{CryptoTypePublicPair, ExposeSecret, KeyTypeId, Pair as PairT, Public, SecretString},
+	crypto::{CryptoTypePublicPair, ExposeSecret, KeyTypeId, Pair as PairT, ByteArray, SecretString},
 	sr25519::{Pair as Sr25519Pair, Public as Sr25519Public},
 	Encode,
 };
@@ -189,7 +189,8 @@ impl SyncCryptoStore for LocalKeystore {
 	) -> std::result::Result<Option<Vec<u8>>, TraitError> {
 		match key.0 {
 			ed25519::CRYPTO_ID => {
-				let pub_key = ed25519::Public::from_slice(key.1.as_slice());
+				let pub_key = ed25519::Public::from_slice(key.1.as_slice())
+					.map_err(|()| TraitError::Other("Corrupted key - Invalid size".into()))?;
 				let key_pair = self
 					.0
 					.read()
@@ -198,7 +199,8 @@ impl SyncCryptoStore for LocalKeystore {
 				key_pair.map(|k| k.sign(msg).encode()).map(Ok).transpose()
 			},
 			sr25519::CRYPTO_ID => {
-				let pub_key = sr25519::Public::from_slice(key.1.as_slice());
+				let pub_key = sr25519::Public::from_slice(key.1.as_slice())
+					.map_err(|()| TraitError::Other("Corrupted key - Invalid size".into()))?;
 				let key_pair = self
 					.0
 					.read()
@@ -207,7 +209,8 @@ impl SyncCryptoStore for LocalKeystore {
 				key_pair.map(|k| k.sign(msg).encode()).map(Ok).transpose()
 			},
 			ecdsa::CRYPTO_ID => {
-				let pub_key = ecdsa::Public::from_slice(key.1.as_slice());
+				let pub_key = ecdsa::Public::from_slice(key.1.as_slice())
+					.map_err(|()| TraitError::Other("Corrupted key - Invalid size".into()))?;
 				let key_pair = self
 					.0
 					.read()
@@ -223,7 +226,7 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().map(|k| sr25519::Public::from_slice(k.as_slice())).collect())
+			.map(|v| v.into_iter().filter_map(|k| sr25519::Public::from_slice(k.as_slice()).ok()).collect())
 			.unwrap_or_default()
 	}
 
@@ -246,7 +249,7 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().map(|k| ed25519::Public::from_slice(k.as_slice())).collect())
+			.map(|v| v.into_iter().filter_map(|k| ed25519::Public::from_slice(k.as_slice()).ok()).collect())
 			.unwrap_or_default()
 	}
 
@@ -269,7 +272,7 @@ impl SyncCryptoStore for LocalKeystore {
 		self.0
 			.read()
 			.raw_public_keys(key_type)
-			.map(|v| v.into_iter().map(|k| ecdsa::Public::from_slice(k.as_slice())).collect())
+			.map(|v| v.into_iter().filter_map(|k| ecdsa::Public::from_slice(k.as_slice()).ok()).collect())
 			.unwrap_or_default()
 	}
 
@@ -562,7 +565,7 @@ mod tests {
 
 		fn public_keys<Public: AppPublic>(&self) -> Result<Vec<Public>> {
 			self.raw_public_keys(Public::ID)
-				.map(|v| v.into_iter().map(|k| Public::from_slice(k.as_slice())).collect())
+				.map(|v| v.into_iter().filter_map(|k| Public::from_slice(k.as_slice()).ok()).collect())
 		}
 
 		fn generate<Pair: AppPair>(&mut self) -> Result<Pair> {

frame/authorship/src/lib.rs

@@ -170,7 +170,9 @@ pub mod pallet {
 
 			<DidSetUncles<T>>::put(false);
 
-			T::EventHandler::note_author(Self::author());
+			if let Some(author) = Self::author() {
+				T::EventHandler::note_author(author);
+			}
 
 			0
 		}
@@ -300,19 +302,19 @@ impl<T: Config> Pallet<T> {
 	///
 	/// This is safe to invoke in `on_initialize` implementations, as well
 	/// as afterwards.
-	pub fn author() -> T::AccountId {
+	pub fn author() -> Option<T::AccountId> {
 		// Check the memoized storage value.
 		if let Some(author) = <Author<T>>::get() {
-			return author
+			return Some(author)
 		}
 
 		let digest = <frame_system::Pallet<T>>::digest();
 		let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
 		if let Some(author) = T::FindAuthor::find_author(pre_runtime_digests) {
 			<Author<T>>::put(&author);
-			author
+			Some(author)
 		} else {
-			Default::default()
+			None
 		}
 	}
 
@@ -329,14 +331,13 @@ impl<T: Config> Pallet<T> {
 				UncleEntryItem::InclusionHeight(_) => None,
 				UncleEntryItem::Uncle(h, _) => Some(h),
 			});
-			let author = Self::verify_uncle(&uncle, prev_uncles, &mut acc)?;
+			let maybe_author = Self::verify_uncle(&uncle, prev_uncles, &mut acc)?;
 			let hash = uncle.hash();
 
-			T::EventHandler::note_uncle(
-				author.clone().unwrap_or_default(),
-				now - uncle.number().clone(),
-			);
-			uncles.push(UncleEntryItem::Uncle(hash, author));
+			if let Some(author) = maybe_author.clone() {
+				T::EventHandler::note_uncle(author, now - uncle.number().clone());
+			}
+			uncles.push(UncleEntryItem::Uncle(hash, maybe_author));
 		}
 
 		<Uncles<T>>::put(&uncles);

frame/babe/src/equivocation.rs

@@ -176,7 +176,7 @@ where
 	}
 
 	fn block_author() -> Option<T::AccountId> {
-		Some(<pallet_authorship::Pallet<T>>::author())
+		<pallet_authorship::Pallet<T>>::author()
 	}
 }
 

frame/benchmarking/src/utils.rs

@@ -321,17 +321,17 @@ pub trait BenchmarkingSetup<T, I = ()> {
 }
 
 /// Grab an account, seeded by a name and index.
-pub fn account<AccountId: Decode + Default>(
+pub fn account<AccountId: Decode>(
 	name: &'static str,
 	index: u32,
 	seed: u32,
 ) -> AccountId {
 	let entropy = (name, index, seed).using_encoded(blake2_256);
-	AccountId::decode(&mut &entropy[..]).unwrap_or_default()
+	AccountId::decode(&mut &entropy[..]).expect("`AccountId` type must be able to decode from any 32 bytes; qed")
 }
 
 /// This caller account is automatically whitelisted for DB reads/writes by the benchmarking macro.
-pub fn whitelisted_caller<AccountId: Decode + Default>() -> AccountId {
+pub fn whitelisted_caller<AccountId: Decode>() -> AccountId {
 	account::<AccountId>("whitelisted_caller", 0, 0)
 }
 

frame/elections-phragmen/src/lib.rs

@@ -147,7 +147,7 @@ pub enum Renouncing {
 }
 
 /// An active voter.
-#[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq, TypeInfo)]
+#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, TypeInfo)]
 pub struct Voter<AccountId, Balance> {
 	/// The members being backed.
 	pub votes: Vec<AccountId>,
@@ -159,6 +159,16 @@ pub struct Voter<AccountId, Balance> {
 	pub deposit: Balance,
 }
 
+impl<AccountId, Balance: Default> Default for Voter<AccountId, Balance> {
+	fn default() -> Self {
+		Self {
+			votes: vec![],
+			stake: Default::default(),
+			deposit: Default::default(),
+		}
+	}
+}
+
 /// A holder of a seat as either a member or a runner-up.
 #[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq, TypeInfo)]
 pub struct SeatHolder<AccountId, Balance> {

frame/examples/parallel/src/lib.rs

@@ -105,13 +105,15 @@ pub struct EnlistedParticipant {
 
 impl EnlistedParticipant {
 	fn verify(&self, event_id: &[u8]) -> bool {
-		use sp_core::Public;
+		use sp_core::ByteArray;
 		use sp_runtime::traits::Verify;
 
 		match sp_core::sr25519::Signature::try_from(&self.signature[..]) {
 			Ok(signature) => {
-				let public = sp_core::sr25519::Public::from_slice(self.account.as_ref());
-				signature.verify(event_id, &public)
+				match sp_core::sr25519::Public::from_slice(self.account.as_ref()) {
+					Err(()) => false,
+					Ok(signer) => signature.verify(event_id, &signer),
+				}
 			},
 			_ => false,
 		}

frame/grandpa/src/equivocation.rs

@@ -185,7 +185,7 @@ where
 	}
 
 	fn block_author() -> Option<T::AccountId> {
-		Some(<pallet_authorship::Pallet<T>>::author())
+		<pallet_authorship::Pallet<T>>::author()
 	}
 }
 

frame/multisig/src/lib.rs

@@ -508,7 +508,7 @@ impl<T: Config> Pallet<T> {
 	/// NOTE: `who` must be sorted. If it is not, then you'll get the wrong answer.
 	pub fn multi_account_id(who: &[T::AccountId], threshold: u16) -> T::AccountId {
 		let entropy = (b"modlpy/utilisuba", who, threshold).using_encoded(blake2_256);
-		T::AccountId::decode(&mut &entropy[..]).unwrap_or_default()
+		T::AccountId::decode(&mut &entropy[..]).expect("`AccountId` is never larger than 256 bits; qed")
 	}
 
 	fn operate(

frame/proxy/src/lib.rs

@@ -653,7 +653,7 @@ impl<T: Config> Pallet<T> {
 		});
 		let entropy = (b"modlpy/proxy____", who, height, ext_index, proxy_type, index)
 			.using_encoded(blake2_256);
-		T::AccountId::decode(&mut &entropy[..]).unwrap_or_default()
+		T::AccountId::decode(&mut &entropy[..]).expect("`AccountId` type is never greater than 32 bytes; qed")
 	}
 
 	/// Register a proxy account for the delegator that is able to make calls on its behalf.

frame/session/src/lib.rs

@@ -312,8 +312,9 @@ impl<AId> SessionHandler<AId> for Tuple {
 		for_tuples!(
 			#(
 				let our_keys: Box<dyn Iterator<Item=_>> = Box::new(validators.iter()
-					.map(|k| (&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)
-						.unwrap_or_default())));
+					.filter_map(|k|
+						(&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)))
+					);
 
 				Tuple::on_genesis_session(our_keys);
 			)*
@@ -328,11 +329,13 @@ impl<AId> SessionHandler<AId> for Tuple {
 		for_tuples!(
 			#(
 				let our_keys: Box<dyn Iterator<Item=_>> = Box::new(validators.iter()
-					.map(|k| (&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)
-						.unwrap_or_default())));
+					.filter_map(|k|
+						(&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)))
+					);
 				let queued_keys: Box<dyn Iterator<Item=_>> = Box::new(queued_validators.iter()
-					.map(|k| (&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)
-						.unwrap_or_default())));
+					.filter_map(|k|
+						(&k.0, k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID)))
+					);
 				Tuple::on_new_session(changed, our_keys, queued_keys);
 			)*
 		)

frame/staking/src/pallet/impls.rs

@@ -1109,7 +1109,9 @@ where
 		Self::reward_by_ids(vec![(author, 20)])
 	}
 	fn note_uncle(author: T::AccountId, _age: T::BlockNumber) {
-		Self::reward_by_ids(vec![(<pallet_authorship::Pallet<T>>::author(), 2), (author, 1)])
+		if let Some(author) = <pallet_authorship::Pallet<T>>::author() {
+			Self::reward_by_ids(vec![(author, 2), (author, 1)])
+		}
 	}
 }
 

frame/staking/src/tests.rs

@@ -2051,7 +2051,7 @@ fn reward_from_authorship_event_handler_works() {
 	ExtBuilder::default().build_and_execute(|| {
 		use pallet_authorship::EventHandler;
 
-		assert_eq!(<pallet_authorship::Pallet<Test>>::author(), 11);
+		assert_eq!(<pallet_authorship::Pallet<Test>>::author(), Some(11));
 
 		<Pallet<Test>>::note_author(11);
 		<Pallet<Test>>::note_uncle(21, 1);

frame/sudo/src/lib.rs

@@ -274,20 +274,22 @@ pub mod pallet {
 	#[pallet::genesis_config]
 	pub struct GenesisConfig<T: Config> {
 		/// The `AccountId` of the sudo key.
-		pub key: T::AccountId,
+		pub key: Option<T::AccountId>,
 	}
 
 	#[cfg(feature = "std")]
 	impl<T: Config> Default for GenesisConfig<T> {
 		fn default() -> Self {
-			Self { key: Default::default() }
+			Self { key: None }
 		}
 	}
 
 	#[pallet::genesis_build]
 	impl<T: Config> GenesisBuild<T> for GenesisConfig<T> {
 		fn build(&self) {
-			<Key<T>>::put(&self.key);
+			if let Some(ref key) = self.key {
+				<Key<T>>::put(key);
+			}
 		}
 	}
 }

frame/support/src/traits/validation.rs

@@ -77,7 +77,7 @@ pub trait VerifySeal<Header, Author> {
 /// A session handler for specific key type.
 pub trait OneSessionHandler<ValidatorId>: BoundToRuntimeAppPublic {
 	/// The key type expected.
-	type Key: Decode + Default + RuntimeAppPublic;
+	type Key: Decode + RuntimeAppPublic;
 
 	/// The given validator set will be used for the genesis session.
 	/// It is guaranteed that the given validator set will also be used

frame/system/src/lib.rs

@@ -235,7 +235,6 @@ pub mod pallet {
 			+ Debug
 			+ MaybeDisplay
 			+ Ord
-			+ Default
 			+ MaxEncodedLen;
 
 		/// Converting trait to take a source type and convert to `AccountId`.

frame/transaction-payment/asset-tx-payment/src/tests.rs

@@ -199,10 +199,11 @@ impl pallet_authorship::Config for Runtime {
 pub struct CreditToBlockAuthor;
 impl HandleCredit<AccountId, Assets> for CreditToBlockAuthor {
 	fn handle_credit(credit: CreditOf<AccountId, Assets>) {
-		let author = pallet_authorship::Pallet::<Runtime>::author();
-		// What to do in case paying the author fails (e.g. because `fee < min_balance`)
-		// default: drop the result which will trigger the `OnDrop` of the imbalance.
-		let _ = <Assets as Balanced<AccountId>>::resolve(&author, credit);
+		if let Some(author) = pallet_authorship::Pallet::<Runtime>::author() {
+			// What to do in case paying the author fails (e.g. because `fee < min_balance`)
+			// default: drop the result which will trigger the `OnDrop` of the imbalance.
+			let _ = <Assets as Balanced<AccountId>>::resolve(&author, credit);
+		}
 	}
 }
 

primitives/application-crypto/src/ecdsa.rs

@@ -57,6 +57,6 @@ impl RuntimePublic for Public {
 	}
 
 	fn to_raw_vec(&self) -> Vec<u8> {
-		sp_core::crypto::Public::to_raw_vec(self)
+		sp_core::crypto::ByteArray::to_raw_vec(self)
 	}
 }

primitives/application-crypto/src/ed25519.rs

@@ -57,6 +57,6 @@ impl RuntimePublic for Public {
 	}
 
 	fn to_raw_vec(&self) -> Vec<u8> {
-		sp_core::crypto::Public::to_raw_vec(self)
+		sp_core::crypto::ByteArray::to_raw_vec(self)
 	}
 }