Migrate pallet-membership to the new pallet attribute macro (#9080)

* Migrate pallet-membership to new pallet attribute macro Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Add migrations Signed-off-by: koushiro <koushiro.cqx@gmail.com> * more general Signed-off-by: koushiro <koushiro.cqx@gmail.com> * fix event metadata Signed-off-by: koushiro <koushiro.cqx@gmail.com> * some nits Signed-off-by: koushiro <koushiro.cqx@gmail.com> * fix some nits Signed-off-by: koushiro <koushiro.cqx@gmail.com> * apply suggestion Signed-off-by: koushiro <koushiro.cqx@gmail.com> * some nits Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Remove useless Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix migration Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix format Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix migration now we need to store the new version manually. * Fix migration and Add migration test Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Fix format Signed-off-by: koushiro <koushiro.cqx@gmail.com> * Use new_test_ext Signed-off-by: koushiro <koushiro.cqx@gmail.com> Co-authored-by: thiolliere <gui.thiolliere@gmail.com>
2026-05-01 13:37:57 +00:00 · 2021-09-07 20:17:26 +08:00
parent 224c7f10b9
commit 03b294641e
4 changed files with 362 additions and 132 deletions
@@ -15,25 +15,25 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false }
 log = { version = "0.4.0", default-features = false }
-sp-std = { version = "4.0.0-dev", default-features = false, path = "../../primitives/std" }
+
+sp-core = { version = "4.0.0-dev", default-features = false, path = "../../primitives/core" }
 sp-io = { version = "4.0.0-dev", default-features = false, path = "../../primitives/io" }
 sp-runtime = { version = "4.0.0-dev", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "4.0.0-dev", default-features = false, path = "../../primitives/std" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }

-frame-benchmarking = { version = "4.0.0-dev", optional = true, default-features = false, path = "../benchmarking" }
-
-[dev-dependencies]
-sp-core = { version = "4.0.0-dev", path = "../../primitives/core" }
-
 [features]
 default = ["std"]
 std = [
 	"codec/std",
 	"log/std",
-	"sp-std/std",
+	"sp-core/std",
 	"sp-io/std",
 	"sp-runtime/std",
+	"sp-std/std",
 	"frame-support/std",
 	"frame-system/std",
 	"frame-benchmarking/std",
@@ -23,84 +23,118 @@
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]

-use frame_support::{
-	decl_error, decl_event, decl_module, decl_storage,
-	traits::{ChangeMembers, Contains, EnsureOrigin, Get, InitializeMembers, SortedMembers},
+use frame_support::traits::{
+	ChangeMembers, Contains, Get, InitializeMembers, SortedMembers, StorageVersion,
 };
-use frame_system::ensure_signed;
 use sp_std::prelude::*;

+pub mod migrations;
 pub mod weights;
+
+pub use pallet::*;
 pub use weights::WeightInfo;

-pub trait Config<I = DefaultInstance>: frame_system::Config {
-	/// The overarching event type.
-	type Event: From<Event<Self, I>> + Into<<Self as frame_system::Config>::Event>;
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;

-	/// Required origin for adding a member (though can always be Root).
-	type AddOrigin: EnsureOrigin<Self::Origin>;
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);

-	/// Required origin for removing a member (though can always be Root).
-	type RemoveOrigin: EnsureOrigin<Self::Origin>;
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

-	/// Required origin for adding and removing a member in a single action.
-	type SwapOrigin: EnsureOrigin<Self::Origin>;
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type Event: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::Event>;

-	/// Required origin for resetting membership.
-	type ResetOrigin: EnsureOrigin<Self::Origin>;
+		/// Required origin for adding a member (though can always be Root).
+		type AddOrigin: EnsureOrigin<Self::Origin>;

-	/// Required origin for setting or resetting the prime member.
-	type PrimeOrigin: EnsureOrigin<Self::Origin>;
+		/// Required origin for removing a member (though can always be Root).
+		type RemoveOrigin: EnsureOrigin<Self::Origin>;

-	/// The receiver of the signal for when the membership has been initialized. This happens pre-
-	/// genesis and will usually be the same as `MembershipChanged`. If you need to do something
-	/// different on initialization, then you can change this accordingly.
-	type MembershipInitialized: InitializeMembers<Self::AccountId>;
+		/// Required origin for adding and removing a member in a single action.
+		type SwapOrigin: EnsureOrigin<Self::Origin>;

-	/// The receiver of the signal for when the membership has changed.
-	type MembershipChanged: ChangeMembers<Self::AccountId>;
+		/// Required origin for resetting membership.
+		type ResetOrigin: EnsureOrigin<Self::Origin>;

-	/// The maximum number of members that this membership can have.
-	///
-	/// This is used for benchmarking. Re-run the benchmarks if this changes.
-	///
-	/// This is not enforced in the code; the membership size can exceed this limit.
-	type MaxMembers: Get<u32>;
+		/// Required origin for setting or resetting the prime member.
+		type PrimeOrigin: EnsureOrigin<Self::Origin>;

-	/// Weight information for extrinsics in this pallet.
-	type WeightInfo: WeightInfo;
-}
+		/// The receiver of the signal for when the membership has been initialized. This happens
+		/// pre-genesis and will usually be the same as `MembershipChanged`. If you need to do
+		/// something different on initialization, then you can change this accordingly.
+		type MembershipInitialized: InitializeMembers<Self::AccountId>;

-decl_storage! {
-	trait Store for Module<T: Config<I>, I: Instance=DefaultInstance> as Membership {
-		/// The current membership, stored as an ordered Vec.
-		Members get(fn members): Vec<T::AccountId>;
+		/// The receiver of the signal for when the membership has changed.
+		type MembershipChanged: ChangeMembers<Self::AccountId>;

-		/// The current prime member, if one exists.
-		Prime get(fn prime): Option<T::AccountId>;
+		/// The maximum number of members that this membership can have.
+		///
+		/// This is used for benchmarking. Re-run the benchmarks if this changes.
+		///
+		/// This is not enforced in the code; the membership size can exceed this limit.
+		type MaxMembers: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
 	}
-	add_extra_genesis {
-		config(members): Vec<T::AccountId>;
-		config(phantom): sp_std::marker::PhantomData<I>;
-		build(|config: &Self| {
-			let mut members = config.members.clone();

+	/// The current membership, stored as an ordered Vec.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+
+	/// The current prime member, if one exists.
+	#[pallet::storage]
+	#[pallet::getter(fn prime)]
+	pub type Prime<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub members: Vec<T::AccountId>,
+		pub phantom: PhantomData<I>,
+	}
+
+	#[cfg(feature = "std")]
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self { members: Vec::new(), phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig<T, I> {
+		fn build(&self) {
 			use sp_std::collections::btree_set::BTreeSet;
-			let members_set: BTreeSet<_> = config.members.iter().collect();
-			assert!(members_set.len() == config.members.len(), "Members cannot contain duplicate accounts.");
+			let members_set: BTreeSet<_> = self.members.iter().collect();
+			assert_eq!(
+				members_set.len(),
+				self.members.len(),
+				"Members cannot contain duplicate accounts."
+			);

+			let mut members = self.members.clone();
 			members.sort();
 			T::MembershipInitialized::initialize_members(&members);
 			<Members<T, I>>::put(members);
-		})
+		}
 	}
-}

-decl_event!(
-	pub enum Event<T, I=DefaultInstance> where
-		<T as frame_system::Config>::AccountId,
-		<T as Config<I>>::Event,
-	{
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	#[pallet::metadata(
+		PhantomData<(T::AccountId, <T as Config<I>>::Event)> = "sp_std::marker::PhantomData<(AccountId, Event)>",
+	)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
 		/// The given member was added; see the transaction for who.
 		MemberAdded,
 		/// The given member was removed; see the transaction for who.
@@ -112,34 +146,28 @@ decl_event!(
 		/// One of the members' keys changed.
 		KeyChanged,
 		/// Phantom member, never used.
-		Dummy(sp_std::marker::PhantomData<(AccountId, Event)>),
+		Dummy(PhantomData<(T::AccountId, <T as Config<I>>::Event)>),
 	}
-);

-decl_error! {
-	/// Error for the nicks module.
-	pub enum Error for Module<T: Config<I>, I: Instance> {
+	/// Old name generated by `decl_event`.
+	#[deprecated(note = "use `Event` instead")]
+	pub type RawEvent<T, I = ()> = Event<T, I>;
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
 		/// Already a member.
 		AlreadyMember,
 		/// Not a member.
 		NotMember,
 	}
-}
-
-decl_module! {
-	pub struct Module<T: Config<I>, I: Instance=DefaultInstance>
-		for enum Call
-		where origin: T::Origin
-	{
-		type Error = Error<T, I>;
-
-		fn deposit_event() = default;

+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		/// Add a member `who` to the set.
 		///
 		/// May only be called from `T::AddOrigin`.
-		#[weight = 50_000_000]
-		pub fn add_member(origin, who: T::AccountId) {
+		#[pallet::weight(50_000_000)]
+		pub fn add_member(origin: OriginFor<T>, who: T::AccountId) -> DispatchResult {
 			T::AddOrigin::ensure_origin(origin)?;

 			let mut members = <Members<T, I>>::get();
@@ -151,14 +179,15 @@ decl_module! {

 			T::MembershipChanged::change_members_sorted(&[who], &[], &members[..]);

-			Self::deposit_event(RawEvent::MemberAdded);
+			Self::deposit_event(Event::MemberAdded);
+			Ok(())
 		}

 		/// Remove a member `who` from the set.
 		///
 		/// May only be called from `T::RemoveOrigin`.
-		#[weight = 50_000_000]
-		pub fn remove_member(origin, who: T::AccountId) {
+		#[pallet::weight(50_000_000)]
+		pub fn remove_member(origin: OriginFor<T>, who: T::AccountId) -> DispatchResult {
 			T::RemoveOrigin::ensure_origin(origin)?;

 			let mut members = <Members<T, I>>::get();
@@ -171,7 +200,8 @@ decl_module! {
 			T::MembershipChanged::change_members_sorted(&[], &[who], &members[..]);
 			Self::rejig_prime(&members);

-			Self::deposit_event(RawEvent::MemberRemoved);
+			Self::deposit_event(Event::MemberRemoved);
+			Ok(())
 		}

 		/// Swap out one member `remove` for another `add`.
@@ -179,11 +209,17 @@ decl_module! {
 		/// May only be called from `T::SwapOrigin`.
 		///
 		/// Prime membership is *not* passed from `remove` to `add`, if extant.
-		#[weight = 50_000_000]
-		pub fn swap_member(origin, remove: T::AccountId, add: T::AccountId) {
+		#[pallet::weight(50_000_000)]
+		pub fn swap_member(
+			origin: OriginFor<T>,
+			remove: T::AccountId,
+			add: T::AccountId,
+		) -> DispatchResult {
 			T::SwapOrigin::ensure_origin(origin)?;

-			if remove == add { return Ok(()) }
+			if remove == add {
+				return Ok(())
+			}

 			let mut members = <Members<T, I>>::get();
 			let location = members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
@@ -194,22 +230,19 @@ decl_module! {
 			Self::maybe_warn_max_members(&members);
 			<Members<T, I>>::put(&members);

-			T::MembershipChanged::change_members_sorted(
-				&[add],
-				&[remove],
-				&members[..],
-			);
+			T::MembershipChanged::change_members_sorted(&[add], &[remove], &members[..]);
 			Self::rejig_prime(&members);

-			Self::deposit_event(RawEvent::MembersSwapped);
+			Self::deposit_event(Event::MembersSwapped);
+			Ok(())
 		}

 		/// Change the membership to a new set, disregarding the existing membership. Be nice and
 		/// pass `members` pre-sorted.
 		///
 		/// May only be called from `T::ResetOrigin`.
-		#[weight = 50_000_000]
-		pub fn reset_members(origin, members: Vec<T::AccountId>) {
+		#[pallet::weight(50_000_000)]
+		pub fn reset_members(origin: OriginFor<T>, members: Vec<T::AccountId>) -> DispatchResult {
 			T::ResetOrigin::ensure_origin(origin)?;

 			let mut members = members;
@@ -221,7 +254,8 @@ decl_module! {
 				*m = members;
 			});

-			Self::deposit_event(RawEvent::MembersReset);
+			Self::deposit_event(Event::MembersReset);
+			Ok(())
 		}

 		/// Swap out the sending member for some other key `new`.
@@ -229,13 +263,14 @@ decl_module! {
 		/// May only be called from `Signed` origin of a current member.
 		///
 		/// Prime membership is passed from the origin account to `new`, if extant.
-		#[weight = 50_000_000]
-		pub fn change_key(origin, new: T::AccountId) {
+		#[pallet::weight(50_000_000)]
+		pub fn change_key(origin: OriginFor<T>, new: T::AccountId) -> DispatchResult {
 			let remove = ensure_signed(origin)?;

 			if remove != new {
 				let mut members = <Members<T, I>>::get();
-				let location = members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
+				let location =
+					members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
 				let _ = members.binary_search(&new).err().ok_or(Error::<T, I>::AlreadyMember)?;
 				members[location] = new.clone();
 				members.sort();
@@ -255,33 +290,36 @@ decl_module! {
 				}
 			}

-			Self::deposit_event(RawEvent::KeyChanged);
+			Self::deposit_event(Event::KeyChanged);
+			Ok(())
 		}

 		/// Set the prime member. Must be a current member.
 		///
 		/// May only be called from `T::PrimeOrigin`.
-		#[weight = 50_000_000]
-		pub fn set_prime(origin, who: T::AccountId) {
+		#[pallet::weight(50_000_000)]
+		pub fn set_prime(origin: OriginFor<T>, who: T::AccountId) -> DispatchResult {
 			T::PrimeOrigin::ensure_origin(origin)?;
 			Self::members().binary_search(&who).ok().ok_or(Error::<T, I>::NotMember)?;
 			Prime::<T, I>::put(&who);
 			T::MembershipChanged::set_prime(Some(who));
+			Ok(())
 		}

 		/// Remove the prime member if it exists.
 		///
 		/// May only be called from `T::PrimeOrigin`.
-		#[weight = 50_000_000]
-		pub fn clear_prime(origin) {
+		#[pallet::weight(50_000_000)]
+		pub fn clear_prime(origin: OriginFor<T>) -> DispatchResult {
 			T::PrimeOrigin::ensure_origin(origin)?;
 			Prime::<T, I>::kill();
 			T::MembershipChanged::set_prime(None);
+			Ok(())
 		}
 	}
 }

-impl<T: Config<I>, I: Instance> Module<T, I> {
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	fn rejig_prime(members: &[T::AccountId]) {
 		if let Some(prime) = Prime::<T, I>::get() {
 			match members.binary_search(&prime) {
@@ -303,13 +341,13 @@ impl<T: Config<I>, I: Instance> Module<T, I> {
 	}
 }

-impl<T: Config<I>, I: Instance> Contains<T::AccountId> for Module<T, I> {
+impl<T: Config<I>, I: 'static> Contains<T::AccountId> for Pallet<T, I> {
 	fn contains(t: &T::AccountId) -> bool {
 		Self::members().binary_search(t).is_ok()
 	}
 }

-impl<T: Config<I>, I: Instance> SortedMembers<T::AccountId> for Module<T, I> {
+impl<T: Config<I>, I: 'static> SortedMembers<T::AccountId> for Pallet<T, I> {
 	fn sorted_members() -> Vec<T::AccountId> {
 		Self::members()
 	}
@@ -321,26 +359,28 @@ impl<T: Config<I>, I: Instance> SortedMembers<T::AccountId> for Module<T, I> {

 #[cfg(feature = "runtime-benchmarks")]
 mod benchmark {
-	use super::{Module as Membership, *};
-	use frame_benchmarking::{account, benchmarks_instance, impl_benchmark_test_suite, whitelist};
+	use super::{Pallet as Membership, *};
+	use frame_benchmarking::{
+		account, benchmarks_instance_pallet, impl_benchmark_test_suite, whitelist,
+	};
 	use frame_support::{assert_ok, traits::EnsureOrigin};
 	use frame_system::RawOrigin;

 	const SEED: u32 = 0;

-	fn set_members<T: Config<I>, I: Instance>(members: Vec<T::AccountId>, prime: Option<usize>) {
+	fn set_members<T: Config<I>, I: 'static>(members: Vec<T::AccountId>, prime: Option<usize>) {
 		let reset_origin = T::ResetOrigin::successful_origin();
 		let prime_origin = T::PrimeOrigin::successful_origin();

-		assert_ok!(<Membership<T, _>>::reset_members(reset_origin, members.clone()));
+		assert_ok!(<Membership<T, I>>::reset_members(reset_origin, members.clone()));
 		if let Some(prime) = prime.map(|i| members[i].clone()) {
-			assert_ok!(<Membership<T, _>>::set_prime(prime_origin, prime));
+			assert_ok!(<Membership<T, I>>::set_prime(prime_origin, prime));
 		} else {
-			assert_ok!(<Membership<T, _>>::clear_prime(prime_origin));
+			assert_ok!(<Membership<T, I>>::clear_prime(prime_origin));
 		}
 	}

-	benchmarks_instance! {
+	benchmarks_instance_pallet! {
 		add_member {
 			let m in 1 .. T::MaxMembers::get();

@@ -348,10 +388,10 @@ mod benchmark {
 			set_members::<T, I>(members.clone(), None);
 			let new_member = account::<T::AccountId>("add", m, SEED);
 		}: {
-			assert_ok!(<Membership<T, _>>::add_member(T::AddOrigin::successful_origin(), new_member.clone()));
+			assert_ok!(<Membership<T, I>>::add_member(T::AddOrigin::successful_origin(), new_member.clone()));
 		}
 		verify {
-			assert!(<Members<T, _>>::get().contains(&new_member));
+			assert!(<Members<T, I>>::get().contains(&new_member));
 			#[cfg(test)] crate::tests::clean();
 		}

@@ -365,11 +405,11 @@ mod benchmark {

 			let to_remove = members.first().cloned().unwrap();
 		}: {
-			assert_ok!(<Membership<T, _>>::remove_member(T::RemoveOrigin::successful_origin(), to_remove.clone()));
+			assert_ok!(<Membership<T, I>>::remove_member(T::RemoveOrigin::successful_origin(), to_remove.clone()));
 		} verify {
-			assert!(!<Members<T, _>>::get().contains(&to_remove));
+			assert!(!<Members<T, I>>::get().contains(&to_remove));
 			// prime is rejigged
-			assert!(<Prime<T, _>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
 			#[cfg(test)] crate::tests::clean();
 		}

@@ -382,16 +422,16 @@ mod benchmark {
 			let add = account::<T::AccountId>("member", m, SEED);
 			let remove = members.first().cloned().unwrap();
 		}: {
-			assert_ok!(<Membership<T, _>>::swap_member(
+			assert_ok!(<Membership<T, I>>::swap_member(
 				T::SwapOrigin::successful_origin(),
 				remove.clone(),
 				add.clone(),
 			));
 		} verify {
-			assert!(!<Members<T, _>>::get().contains(&remove));
-			assert!(<Members<T, _>>::get().contains(&add));
+			assert!(!<Members<T, I>>::get().contains(&remove));
+			assert!(<Members<T, I>>::get().contains(&add));
 			// prime is rejigged
-			assert!(<Prime<T, _>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
 			#[cfg(test)] crate::tests::clean();
 		}

@@ -403,12 +443,12 @@ mod benchmark {
 			set_members::<T, I>(members.clone(), Some(members.len() - 1));
 			let mut new_members = (m..2*m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
 		}: {
-			assert_ok!(<Membership<T, _>>::reset_members(T::ResetOrigin::successful_origin(), new_members.clone()));
+			assert_ok!(<Membership<T, I>>::reset_members(T::ResetOrigin::successful_origin(), new_members.clone()));
 		} verify {
 			new_members.sort();
-			assert_eq!(<Members<T, _>>::get(), new_members);
+			assert_eq!(<Members<T, I>>::get(), new_members);
 			// prime is rejigged
-			assert!(<Prime<T, _>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
 			#[cfg(test)] crate::tests::clean();
 		}

@@ -423,12 +463,12 @@ mod benchmark {
 			let add = account::<T::AccountId>("member", m, SEED);
 			whitelist!(prime);
 		}: {
-			assert_ok!(<Membership<T, _>>::change_key(RawOrigin::Signed(prime.clone()).into(), add.clone()));
+			assert_ok!(<Membership<T, I>>::change_key(RawOrigin::Signed(prime.clone()).into(), add.clone()));
 		} verify {
-			assert!(!<Members<T, _>>::get().contains(&prime));
-			assert!(<Members<T, _>>::get().contains(&add));
+			assert!(!<Members<T, I>>::get().contains(&prime));
+			assert!(<Members<T, I>>::get().contains(&add));
 			// prime is rejigged
-			assert_eq!(<Prime<T, _>>::get().unwrap(), add);
+			assert_eq!(<Prime<T, I>>::get().unwrap(), add);
 			#[cfg(test)] crate::tests::clean();
 		}

@@ -438,9 +478,9 @@ mod benchmark {
 			let prime = members.last().cloned().unwrap();
 			set_members::<T, I>(members, None);
 		}: {
-			assert_ok!(<Membership<T, _>>::set_prime(T::PrimeOrigin::successful_origin(), prime));
+			assert_ok!(<Membership<T, I>>::set_prime(T::PrimeOrigin::successful_origin(), prime));
 		} verify {
-			assert!(<Prime<T, _>>::get().is_some());
+			assert!(<Prime<T, I>>::get().is_some());
 			assert!(<T::MembershipChanged>::get_prime().is_some());
 			#[cfg(test)] crate::tests::clean();
 		}
@@ -451,9 +491,9 @@ mod benchmark {
 			let prime = members.last().cloned().unwrap();
 			set_members::<T, I>(members, None);
 		}: {
-			assert_ok!(<Membership<T, _>>::clear_prime(T::PrimeOrigin::successful_origin()));
+			assert_ok!(<Membership<T, I>>::clear_prime(T::PrimeOrigin::successful_origin()));
 		} verify {
-			assert!(<Prime<T, _>>::get().is_none());
+			assert!(<Prime<T, I>>::get().is_none());
 			assert!(<T::MembershipChanged>::get_prime().is_none());
 			#[cfg(test)] crate::tests::clean();
 		}
@@ -467,14 +507,17 @@ mod tests {
 	use super::*;
 	use crate as pallet_membership;

-	use frame_support::{assert_noop, assert_ok, ord_parameter_types, parameter_types};
-	use frame_system::EnsureSignedBy;
 	use sp_core::H256;
 	use sp_runtime::{
 		testing::Header,
 		traits::{BadOrigin, BlakeTwo256, IdentityLookup},
 	};

+	use frame_support::{
+		assert_noop, assert_ok, ord_parameter_types, parameter_types, traits::GenesisBuild,
+	};
+	use frame_system::EnsureSignedBy;
+
 	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
 	type Block = frame_system::mocking::MockBlock<Test>;

@@ -745,4 +788,18 @@ mod tests {
 		.build_storage()
 		.unwrap();
 	}
+
+	#[test]
+	fn migration_v4() {
+		new_test_ext().execute_with(|| {
+			use frame_support::traits::PalletInfo;
+			let old_pallet_name =
+				<Test as frame_system::Config>::PalletInfo::name::<Membership>().unwrap();
+			let new_pallet_name = "NewMembership";
+
+			crate::migrations::v4::pre_migrate::<Membership, _>(old_pallet_name, new_pallet_name);
+			crate::migrations::v4::migrate::<Test, Membership, _>(old_pallet_name, new_pallet_name);
+			crate::migrations::v4::post_migrate::<Membership, _>(old_pallet_name, new_pallet_name);
+		});
+	}
 }
@@ -0,0 +1,19 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Version 4.
+pub mod v4;
@@ -0,0 +1,154 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use sp_core::hexdisplay::HexDisplay;
+use sp_io::{hashing::twox_128, storage};
+
+use frame_support::{
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<MembershipPallet>`.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 4 in order to trigger the
+/// migration.
+pub fn migrate<T: frame_system::Config, P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(
+	old_pallet_name: N,
+	new_pallet_name: N,
+) -> Weight {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+
+	if new_pallet_name == old_pallet_name {
+		log::info!(
+			target: "runtime::membership",
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return 0
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: "runtime::membership",
+		"Running migration to v4 for membership with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		frame_support::storage::migration::move_pallet(
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", old_pallet_name, new_pallet_name);
+
+		StorageVersion::new(4).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: "runtime::membership",
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		0
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migrate<P: GetStorageVersion, N: AsRef<str>>(old_pallet_name: N, new_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	log_migration("pre-migration", old_pallet_name, new_pallet_name);
+
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	assert!(storage::next_key(&old_pallet_prefix)
+		.map_or(true, |next_key| next_key.starts_with(&old_pallet_prefix)));
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key =
+		[&new_pallet_prefix, &twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX)[..]].concat();
+	// ensure nothing is stored in the new prefix.
+	assert!(
+		storage::next_key(&new_pallet_prefix).map_or(
+			// either nothing is there
+			true,
+			// or we ensure that it has no common prefix with twox_128(new),
+			// or isn't the storage version that is already stored using the pallet name
+			|next_key| {
+				!next_key.starts_with(&new_pallet_prefix) || next_key == storage_version_key
+			},
+		),
+		"unexpected next_key({}) = {:?}",
+		new_pallet_name,
+		HexDisplay::from(&storage::next_key(&new_pallet_prefix).unwrap()),
+	);
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<P: GetStorageVersion, N: AsRef<str>>(old_pallet_name: N, new_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	log_migration("post-migration", old_pallet_name, new_pallet_name);
+
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	#[cfg(test)]
+	{
+		let storage_version_key =
+			[&old_pallet_prefix, &twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX)[..]].concat();
+		assert!(storage::next_key(&old_pallet_prefix)
+			.map_or(true, |next_key| !next_key.starts_with(&old_pallet_prefix) ||
+				next_key == storage_version_key));
+	}
+	#[cfg(not(test))]
+	{
+		// Assert that nothing remains at the old prefix
+		assert!(storage::next_key(&old_pallet_prefix)
+			.map_or(true, |next_key| !next_key.starts_with(&old_pallet_prefix)));
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	// Assert that the storages have been moved to the new prefix
+	assert!(storage::next_key(&new_pallet_prefix)
+		.map_or(true, |next_key| next_key.starts_with(&new_pallet_prefix)));
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 4);
+}
+
+fn log_migration(stage: &str, old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: "runtime::membership",
+		"{}, prefix: '{}' ==> '{}'",
+		stage,
+		old_pallet_name,
+		new_pallet_name,
+	);
+}