mid merge

Author: jordy25519

Cargo.lock

@@ -31,7 +31,7 @@ use sp_core::{
 use sp_runtime::traits::{Block as BlockT, HashFor};
 use sp_runtime::Storage;
 use sp_state_machine::{
-	DBValue, backend::Backend as StateBackend, StorageCollection, ChildStorageCollection
+	DBValue, backend::Backend as StateBackend, StorageCollection, ChildStorageCollection, ProofRecorder,
 };
 use kvdb::{KeyValueDB, DBTransaction};
 use crate::storage_cache::{CachingState, SharedCache, new_shared_cache};
@@ -121,7 +121,7 @@ pub struct BenchmarkingState<B: BlockT> {
 
 impl<B: BlockT> BenchmarkingState<B> {
 	/// Create a new instance that creates a database in a temporary dir.
-	pub fn new(genesis: Storage, _cache_size_mb: Option<usize>) -> Result<Self, String> {
+	pub fn new(genesis: Storage, _cache_size_mb: Option<usize>, record_proof: bool) -> Result<Self, String> {
 		let mut root = B::Hash::default();
 		let mut mdb = MemoryDB::<HashFor<B>>::default();
 		sp_state_machine::TrieDBMut::<HashFor<B>>::new(&mut mdb, &mut root);
@@ -138,6 +138,7 @@ impl<B: BlockT> BenchmarkingState<B> {
 			child_key_tracker: Default::default(),
 			read_write_tracker: Default::default(),
 			whitelist: Default::default(),
+			proof_recorder: record_proof.then(Default::default),
 		};
 
 		state.add_whitelist_to_tracker();
@@ -513,10 +514,6 @@ impl<B: BlockT> StateBackend<HashFor<B>> for BenchmarkingState<B> {
 	fn usage_info(&self) -> sp_state_machine::UsageInfo {
 		self.state.borrow().as_ref().map_or(sp_state_machine::UsageInfo::empty(), |s| s.usage_info())
 	}
-
-	fn proof_size(&self) -> Option<u32> {
-		self.proof_recorder.as_ref().map(|recorder| recorder.estimate_encoded_size() as u32)
-	}
 }
 
 impl<Block: BlockT> std::fmt::Debug for BenchmarkingState<Block> {
@@ -532,7 +529,7 @@ mod test {
 
 	#[test]
 	fn read_to_main_and_child_tries() {
-		let bench_state = BenchmarkingState::<crate::tests::Block>::new(Default::default(), None)
+		let bench_state = BenchmarkingState::<crate::tests::Block>::new(Default::default(), None, false)
 			.unwrap();
 
 		for _ in 0..2 {

client/db/src/bench.rs

@@ -22,7 +22,7 @@ sp-wasm-interface = { version = "3.0.0", path = "../../../primitives/wasm-interf
 sp-runtime-interface = { version = "3.0.0", path = "../../../primitives/runtime-interface" }
 sp-core = { version = "3.0.0", path = "../../../primitives/core" }
 sp-allocator = { version = "3.0.0", path = "../../../primitives/allocator" }
-wasmtime = "0.22"
+wasmtime = "0.24"
 pwasm-utils = "0.14.0"
 
 [dev-dependencies]

client/executor/wasmtime/Cargo.toml

@@ -27,38 +27,14 @@ use frame_support::{
 	inherent::{InherentData, ProvideInherent, InherentIdentifier},
 };
 use codec::{Encode, Decode};
-use frame_system::ensure_none;
 use sp_runtime::traits::{Header as HeaderT, One, Zero};
 use sp_authorship::{INHERENT_IDENTIFIER, UnclesInherentData, InherentError};
 
 const MAX_UNCLES: usize = 10;
 
-pub trait Config: frame_system::Config {
-	/// Find the author of a block.
-	type FindAuthor: FindAuthor<Self::AccountId>;
-	/// The number of blocks back we should accept uncles.
-	/// This means that we will deal with uncle-parents that are
-	/// `UncleGenerations + 1` before `now`.
-	type UncleGenerations: Get<Self::BlockNumber>;
-	/// A filter for uncles within a block. This is for implementing
-	/// further constraints on what uncles can be included, other than their ancestry.
-	///
-	/// For PoW, as long as the seals are checked, there is no need to use anything
-	/// but the `VerifySeal` implementation as the filter. This is because the cost of making many equivocating
-	/// uncles is high.
-	///
-	/// For PoS, there is no such limitation, so a further constraint must be imposed
-	/// beyond a seal check in order to prevent an arbitrary number of
-	/// equivocating uncles from being included.
-	///
-	/// The `OnePerAuthorPerHeight` filter is good for many slot-based PoS
-	/// engines.
-	type FilterUncle: FilterUncle<Self::Header, Self::AccountId>;
-	/// An event handler for authored blocks.
-	type EventHandler: EventHandler<Self::AccountId, Self::BlockNumber>;
-}
+pub use pallet::*;
 
-/// An event handler for the authorship module. There is a dummy implementation
+/// An event handler for the authorship pallet. There is a dummy implementation
 /// for `()`, which does nothing.
 #[impl_trait_for_tuples::impl_for_tuples(30)]
 pub trait EventHandler<Author, BlockNumber> {
@@ -149,41 +125,44 @@ enum UncleEntryItem<BlockNumber, Hash, Author> {
 	InclusionHeight(BlockNumber),
 	Uncle(Hash, Option<Author>),
 }
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use super::*;
 
-decl_storage! {
-	trait Store for Module<T: Config> as Authorship {
-		/// Uncles
-		Uncles: Vec<UncleEntryItem<T::BlockNumber, T::Hash, T::AccountId>>;
-		/// Author of current block.
-		Author: Option<T::AccountId>;
-		/// Whether uncles were already set in this block.
-		DidSetUncles: bool;
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Find the author of a block.
+		type FindAuthor: FindAuthor<Self::AccountId>;
+		/// The number of blocks back we should accept uncles.
+		/// This means that we will deal with uncle-parents that are
+		/// `UncleGenerations + 1` before `now`.
+		type UncleGenerations: Get<Self::BlockNumber>;
+		/// A filter for uncles within a block. This is for implementing
+		/// further constraints on what uncles can be included, other than their ancestry.
+		///
+		/// For PoW, as long as the seals are checked, there is no need to use anything
+		/// but the `VerifySeal` implementation as the filter. This is because the cost of making many equivocating
+		/// uncles is high.
+		///
+		/// For PoS, there is no such limitation, so a further constraint must be imposed
+		/// beyond a seal check in order to prevent an arbitrary number of
+		/// equivocating uncles from being included.
+		///
+		/// The `OnePerAuthorPerHeight` filter is good for many slot-based PoS
+		/// engines.
+		type FilterUncle: FilterUncle<Self::Header, Self::AccountId>;
+		/// An event handler for authored blocks.
+		type EventHandler: EventHandler<Self::AccountId, Self::BlockNumber>;
 	}
-}
 
-decl_error! {
-	/// Error for the authorship module.
-	pub enum Error for Module<T: Config> {
-		/// The uncle parent not in the chain.
-		InvalidUncleParent,
-		/// Uncles already set in the block.
-		UnclesAlreadySet,
-		/// Too many uncles.
-		TooManyUncles,
-		/// The uncle is genesis.
-		GenesisUncle,
-		/// The uncle is too high in chain.
-		TooHighUncle,
-		/// The uncle is already included.
-		UncleAlreadyIncluded,
-		/// The uncle isn't recent enough to be included.
-		OldUncle,
-	}
-}
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
 
-decl_module! {
-	pub struct Module<T: Config> for enum Call where origin: T::Origin {
-		type Error = Error<T>;
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 
 		fn on_initialize(now: T::BlockNumber) -> Weight {
 			let uncle_generations = T::UncleGenerations::get();
@@ -193,60 +172,98 @@ decl_module! {
 				Self::prune_old_uncles(minimum_height)
 			}
 
-			<Self as Store>::DidSetUncles::put(false);
+			<DidSetUncles<T>>::put(false);
 
 			T::EventHandler::note_author(Self::author());
 
 			0
 		}
 
-		fn on_finalize() {
+		fn on_finalize(_: T::BlockNumber) {
 			// ensure we never go to trie with these values.
-			<Self as Store>::Author::kill();
-			<Self as Store>::DidSetUncles::kill();
+			<Author<T>>::kill();
+			<DidSetUncles<T>>::kill();
 		}
+	}
 
+	#[pallet::storage]
+	/// Uncles
+	pub(super) type Uncles<T: Config> = StorageValue<
+		_,
+		Vec<UncleEntryItem<T::BlockNumber, T::Hash, T::AccountId>>,
+		ValueQuery,
+	>;
+
+	#[pallet::storage]
+	/// Author of current block.
+	pub(super) type Author<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::storage]
+	/// Whether uncles were already set in this block.
+	pub(super) type DidSetUncles<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The uncle parent not in the chain.
+		InvalidUncleParent,
+		/// Uncles already set in the block.
+		UnclesAlreadySet,
+		/// Too many uncles.
+		TooManyUncles,
+		/// The uncle is genesis.
+		GenesisUncle,
+		/// The uncle is too high in chain.
+		TooHighUncle,
+		/// The uncle is already included.
+		UncleAlreadyIncluded,
+		/// The uncle isn't recent enough to be included.
+		OldUncle,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
 		/// Provide a set of uncles.
-		#[weight = (0, DispatchClass::Mandatory)]
-		fn set_uncles(origin, new_uncles: Vec<T::Header>) -> dispatch::DispatchResult {
+		#[pallet::weight((0, DispatchClass::Mandatory))]
+		fn set_uncles(origin: OriginFor<T>, new_uncles: Vec<T::Header>) -> DispatchResult {
 			ensure_none(origin)?;
 			ensure!(new_uncles.len() <= MAX_UNCLES, Error::<T>::TooManyUncles);
 
-			if <Self as Store>::DidSetUncles::get() {
+			if <DidSetUncles<T>>::get() {
 				Err(Error::<T>::UnclesAlreadySet)?
 			}
-			<Self as Store>::DidSetUncles::put(true);
+			<DidSetUncles<T>>::put(true);
 
 			Self::verify_and_import_uncles(new_uncles)
 		}
 	}
 }
 
-impl<T: Config> Module<T> {
+impl<T: Config> Pallet<T> {
 	/// Fetch the author of the block.
 	///
 	/// This is safe to invoke in `on_initialize` implementations, as well
 	/// as afterwards.
 	pub fn author() -> T::AccountId {
 		// Check the memoized storage value.
-		if let Some(author) = <Self as Store>::Author::get() {
+		if let Some(author) = <Author<T>>::get() {
 			return author;
 		}
 
-		let digest = <frame_system::Module<T>>::digest();
+		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) {
-			<Self as Store>::Author::put(&author);
+			<Author<T>>::put(&author);
 			author
 		} else {
 			Default::default()
 		}
 	}
 
 	fn verify_and_import_uncles(new_uncles: Vec<T::Header>) -> dispatch::DispatchResult {
-		let now = <frame_system::Module<T>>::block_number();
+		let now = <frame_system::Pallet<T>>::block_number();
 
-		let mut uncles = <Self as Store>::Uncles::get();
+		let mut uncles = <Uncles<T>>::get();
 		uncles.push(UncleEntryItem::InclusionHeight(now));
 
 		let mut acc: <T::FilterUncle as FilterUncle<_, _>>::Accumulator = Default::default();
@@ -267,7 +284,7 @@ impl<T: Config> Module<T> {
 			uncles.push(UncleEntryItem::Uncle(hash, author));
 		}
 
-		<Self as Store>::Uncles::put(&uncles);
+		<Uncles<T>>::put(&uncles);
 		Ok(())
 	}
 
@@ -301,7 +318,7 @@ impl<T: Config> Module<T> {
 
 		{
 			let parent_number = uncle.number().clone() - One::one();
-			let parent_hash = <frame_system::Module<T>>::block_hash(&parent_number);
+			let parent_hash = <frame_system::Pallet<T>>::block_hash(&parent_number);
 			if &parent_hash != uncle.parent_hash() {
 				return Err(Error::<T>::InvalidUncleParent.into());
 			}
@@ -312,7 +329,7 @@ impl<T: Config> Module<T> {
 		}
 
 		let duplicate = existing_uncles.into_iter().find(|h| **h == hash).is_some();
-		let in_chain = <frame_system::Module<T>>::block_hash(uncle.number()) == hash;
+		let in_chain = <frame_system::Pallet<T>>::block_hash(uncle.number()) == hash;
 
 		if duplicate || in_chain {
 			return Err(Error::<T>::UncleAlreadyIncluded.into())
@@ -323,19 +340,19 @@ impl<T: Config> Module<T> {
 	}
 
 	fn prune_old_uncles(minimum_height: T::BlockNumber) {
-		let mut uncles = <Self as Store>::Uncles::get();
+		let mut uncles = <Uncles<T>>::get();
 		let prune_entries = uncles.iter().take_while(|item| match item {
 			UncleEntryItem::Uncle(_, _) => true,
 			UncleEntryItem::InclusionHeight(height) => height < &minimum_height,
 		});
 		let prune_index = prune_entries.count();
 
 		let _ = uncles.drain(..prune_index);
-		<Self as Store>::Uncles::put(uncles);
+		<Uncles<T>>::put(uncles);
 	}
 }
 
-impl<T: Config> ProvideInherent for Module<T> {
+impl<T: Config> ProvideInherent for Pallet<T> {
 	type Call = Call<T>;
 	type Error = InherentError;
 	const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
@@ -345,7 +362,7 @@ impl<T: Config> ProvideInherent for Module<T> {
 		let mut set_uncles = Vec::new();
 
 		if !uncles.is_empty() {
-			let prev_uncles = <Self as Store>::Uncles::get();
+			let prev_uncles = <Uncles<T>>::get();
 			let mut existing_hashes: Vec<_> = prev_uncles.into_iter().filter_map(|entry|
 				match entry {
 					UncleEntryItem::InclusionHeight(_) => None,
@@ -390,6 +407,10 @@ impl<T: Config> ProvideInherent for Module<T> {
 			},
 		}
 	}
+
+	fn is_inherent(call: &Self::Call) -> bool {
+		matches!(call, Call::set_uncles(_))
+	}
 }
 
 #[cfg(test)]
@@ -411,8 +432,8 @@ mod tests {
 			NodeBlock = Block,
 			UncheckedExtrinsic = UncheckedExtrinsic,
 		{
-			System: frame_system::{Module, Call, Config, Storage, Event<T>},
-			Authorship: pallet_authorship::{Module, Call, Storage, Inherent},
+			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+			Authorship: pallet_authorship::{Pallet, Call, Storage, Inherent},
 		}
 	);
 
@@ -445,13 +466,14 @@ mod tests {
 		type OnKilledAccount = ();
 		type SystemWeightInfo = ();
 		type SS58Prefix = ();
+		type OnSetCode = ();
 	}
 
 	parameter_types! {
 		pub const UncleGenerations: u64 = 5;
 	}
 
-	impl Config for Test {
+	impl pallet::Config for Test {
 		type FindAuthor = AuthorGiven;
 		type UncleGenerations = UncleGenerations;
 		type FilterUncle = SealVerify<VerifyBlock>;

frame/authorship/src/lib.rs

@@ -25,7 +25,7 @@ use codec::{Decode, Encode};
 use frame_support::{
 	decl_error, decl_module, decl_storage,
 	dispatch::DispatchResultWithPostInfo,
-	traits::{FindAuthor, Get, KeyOwnerProofSystem, OneSessionHandler, OnTimestampSet},
+	traits::{FindAuthor, Get, KeyOwnerProofSystem, OneSessionHandler, OnTimestampSet, Randomness as RandomnessT},
 	weights::{Pays, Weight},
 	Parameter,
 };