feat: Rebrand Polkadot/Substrate references to PezkuwiChain

This commit systematically rebrands various references from Parity Technologies'
Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk.

Key changes include:
- Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks.
- Modified internal documentation and code comments to reflect PezkuwiChain naming and structure.
- Replaced direct references to  with  or specific paths within the  for XCM, Pezkuwi, and other modules.
- Cleaned up deprecated  issue and PR references in various  and  files, particularly in  and  modules.
- Adjusted image and logo URLs in documentation to point to PezkuwiChain assets.
- Removed or rephrased comments related to external Polkadot/Substrate PRs and issues.

This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.

bizinikiwi/pezframe/membership/Cargo.toml

@@ -0,0 +1,53 @@
+[package]
+name = "pezpallet-membership"
+version = "28.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "FRAME membership management pallet"
+readme = "README.md"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+pezframe-benchmarking = { optional = true, workspace = true }
+pezframe-support = { workspace = true }
+pezframe-system = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive", "serde"], workspace = true }
+pezsp-core = { features = ["serde"], workspace = true }
+pezsp-io = { workspace = true }
+pezsp-runtime = { features = ["serde"], workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"pezframe-benchmarking?/std",
+	"pezframe-support/std",
+	"pezframe-system/std",
+	"log/std",
+	"scale-info/std",
+	"pezsp-core/std",
+	"pezsp-io/std",
+	"pezsp-runtime/std",
+]
+runtime-benchmarks = [
+	"pezframe-benchmarking/runtime-benchmarks",
+	"pezframe-support/runtime-benchmarks",
+	"pezframe-system/runtime-benchmarks",
+	"pezsp-io/runtime-benchmarks",
+	"pezsp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"pezframe-support/try-runtime",
+	"pezframe-system/try-runtime",
+	"pezsp-runtime/try-runtime",
+]

bizinikiwi/pezframe/membership/README.md

@@ -0,0 +1,6 @@
+# Membership Module
+
+Allows control of membership of a set of `AccountId`s, useful for managing membership of a
+collective. A prime member may be set.
+
+License: Apache-2.0

bizinikiwi/pezframe/membership/src/benchmarking.rs

@@ -0,0 +1,178 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+//! Membership pallet benchmarking.
+
+use super::{Pallet as Membership, *};
+use pezframe_benchmarking::v1::{account, benchmarks_instance_pallet, whitelist, BenchmarkError};
+use pezframe_support::{assert_ok, traits::EnsureOrigin};
+use pezframe_system::RawOrigin;
+
+const SEED: u32 = 0;
+
+fn set_members<T: Config<I>, I: 'static>(members: Vec<T::AccountId>, prime: Option<usize>) {
+	let reset_origin = T::ResetOrigin::try_successful_origin()
+		.expect("ResetOrigin has no successful origin required for the benchmark");
+	let prime_origin = T::PrimeOrigin::try_successful_origin()
+		.expect("PrimeOrigin has no successful origin required for the benchmark");
+
+	assert_ok!(Membership::<T, I>::reset_members(reset_origin, members.clone()));
+	if let Some(prime) = prime.map(|i| members[i].clone()) {
+		let prime_lookup = T::Lookup::unlookup(prime);
+		assert_ok!(Membership::<T, I>::set_prime(prime_origin, prime_lookup));
+	} else {
+		assert_ok!(Membership::<T, I>::clear_prime(prime_origin));
+	}
+}
+
+benchmarks_instance_pallet! {
+	add_member {
+		let m in 1 .. (T::MaxMembers::get() - 1);
+
+		let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		set_members::<T, I>(members, None);
+		let new_member = account::<T::AccountId>("add", m, SEED);
+		let new_member_lookup = T::Lookup::unlookup(new_member.clone());
+	}: {
+		assert_ok!(Membership::<T, I>::add_member(
+			T::AddOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			new_member_lookup,
+		));
+	} verify {
+		assert!(Members::<T, I>::get().contains(&new_member));
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	// the case of no prime or the prime being removed is surely cheaper than the case of
+	// reporting a new prime via `MembershipChanged`.
+	remove_member {
+		let m in 2 .. T::MaxMembers::get();
+
+		let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		set_members::<T, I>(members.clone(), Some(members.len() - 1));
+
+		let to_remove = members.first().cloned().unwrap();
+		let to_remove_lookup = T::Lookup::unlookup(to_remove.clone());
+	}: {
+		assert_ok!(Membership::<T, I>::remove_member(
+			T::RemoveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			to_remove_lookup,
+		));
+	} verify {
+		assert!(!Members::<T, I>::get().contains(&to_remove));
+		// prime is rejigged
+		assert!(Prime::<T, I>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	// we remove a non-prime to make sure it needs to be set again.
+	swap_member {
+		let m in 2 .. T::MaxMembers::get();
+
+		let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		set_members::<T, I>(members.clone(), Some(members.len() - 1));
+		let add = account::<T::AccountId>("member", m, SEED);
+		let add_lookup = T::Lookup::unlookup(add.clone());
+		let remove = members.first().cloned().unwrap();
+		let remove_lookup = T::Lookup::unlookup(remove.clone());
+	}: {
+		assert_ok!(Membership::<T, I>::swap_member(
+			T::SwapOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			remove_lookup,
+			add_lookup,
+		));
+	} verify {
+		assert!(!Members::<T, I>::get().contains(&remove));
+		assert!(Members::<T, I>::get().contains(&add));
+		// prime is rejigged
+		assert!(Prime::<T, I>::get().is_some());
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	// er keep the prime common between incoming and outgoing to make sure it is rejigged.
+	reset_members {
+		let m in 1 .. T::MaxMembers::get();
+
+		let members = (1..m+1).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		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, I>::reset_members(
+			T::ResetOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			new_members.clone(),
+		));
+	} verify {
+		new_members.sort();
+		assert_eq!(Members::<T, I>::get(), new_members);
+		// prime is rejigged
+		assert!(Prime::<T, I>::get().is_some());
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	change_key {
+		let m in 1 .. T::MaxMembers::get();
+
+		// worse case would be to change the prime
+		let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		let prime = members.last().cloned().unwrap();
+		set_members::<T, I>(members.clone(), Some(members.len() - 1));
+
+		let add = account::<T::AccountId>("member", m, SEED);
+		let add_lookup = T::Lookup::unlookup(add.clone());
+		whitelist!(prime);
+	}: {
+		assert_ok!(Membership::<T, I>::change_key(RawOrigin::Signed(prime.clone()).into(), add_lookup));
+	} verify {
+		assert!(!Members::<T, I>::get().contains(&prime));
+		assert!(Members::<T, I>::get().contains(&add));
+		// prime is rejigged
+		assert_eq!(Prime::<T, I>::get().unwrap(), add);
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	set_prime {
+		let m in 1 .. T::MaxMembers::get();
+		let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		let prime = members.last().cloned().unwrap();
+		let prime_lookup = T::Lookup::unlookup(prime.clone());
+		set_members::<T, I>(members, None);
+	}: {
+		assert_ok!(Membership::<T, I>::set_prime(
+			T::PrimeOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			prime_lookup,
+		));
+	} verify {
+		assert!(Prime::<T, I>::get().is_some());
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	clear_prime {
+		let members = (0..T::MaxMembers::get()).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		let prime = members.last().cloned().unwrap();
+		set_members::<T, I>(members, None);
+	}: {
+		assert_ok!(Membership::<T, I>::clear_prime(
+			T::PrimeOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		));
+	} verify {
+		assert!(Prime::<T, I>::get().is_none());
+		assert!(<T::MembershipChanged>::get_prime().is_none());
+		#[cfg(test)] crate::mock::clean();
+	}
+
+	impl_benchmark_test_suite!(Membership, crate::mock::new_bench_ext(), crate::mock::Test);
+}

bizinikiwi/pezframe/membership/src/lib.rs

@@ -0,0 +1,415 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+//! # Membership Module
+//!
+//! Allows control of membership of a set of `AccountId`s, useful for managing membership of a
+//! collective. A prime member may be set
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use pezframe_support::{
+	traits::{ChangeMembers, Contains, ContainsLengthBound, Get, InitializeMembers, SortedMembers},
+	BoundedVec,
+};
+use pezsp_runtime::traits::{StaticLookup, UniqueSaturatedInto};
+
+pub mod migrations;
+pub mod weights;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+
+#[cfg(test)]
+mod tests;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+const LOG_TARGET: &str = "runtime::membership";
+
+type AccountIdLookupOf<T> = <<T as pezframe_system::Config>::Lookup as StaticLookup>::Source;
+
+#[pezframe_support::pallet]
+pub mod pallet {
+	use super::*;
+	use pezframe_support::pezpallet_prelude::*;
+	use pezframe_system::pezpallet_prelude::*;
+
+	/// The in-code storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: pezframe_system::Config {
+		/// The overarching event type.
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
+
+		/// Required origin for adding a member (though can always be Root).
+		type AddOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for removing a member (though can always be Root).
+		type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for adding and removing a member in a single action.
+		type SwapOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for resetting membership.
+		type ResetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for setting or resetting the prime member.
+		type PrimeOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// 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>;
+
+		/// The receiver of the signal for when the membership has changed.
+		type MembershipChanged: ChangeMembers<Self::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 enforced in the code; the membership size can not exceed this limit.
+		type MaxMembers: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The current membership, stored as an ordered Vec.
+	#[pallet::storage]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<T::AccountId, T::MaxMembers>, ValueQuery>;
+
+	/// The current prime member, if one exists.
+	#[pallet::storage]
+	pub type Prime<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(pezframe_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub members: BoundedVec<T::AccountId, T::MaxMembers>,
+		#[serde(skip)]
+		pub phantom: PhantomData<I>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			use alloc::collections::btree_set::BTreeSet;
+			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);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_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.
+		MemberRemoved,
+		/// Two members were swapped; see the transaction for who.
+		MembersSwapped,
+		/// The membership was reset; see the transaction for who the new set is.
+		MembersReset,
+		/// One of the members' keys changed.
+		KeyChanged,
+		/// Phantom member, never used.
+		Dummy { _phantom_data: PhantomData<(T::AccountId, <T as Config<I>>::RuntimeEvent)> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Already a member.
+		AlreadyMember,
+		/// Not a member.
+		NotMember,
+		/// Too many members.
+		TooManyMembers,
+	}
+
+	#[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`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::add_member(T::MaxMembers::get()))]
+		pub fn add_member(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::AddOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			let mut members = Members::<T, I>::get();
+			let init_length = members.len();
+			let location = members.binary_search(&who).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members
+				.try_insert(location, who.clone())
+				.map_err(|_| Error::<T, I>::TooManyMembers)?;
+
+			Members::<T, I>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[who], &[], &members[..]);
+
+			Self::deposit_event(Event::MemberAdded);
+
+			Ok(Some(T::WeightInfo::add_member(init_length as u32)).into())
+		}
+
+		/// Remove a member `who` from the set.
+		///
+		/// May only be called from `T::RemoveOrigin`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::remove_member(T::MaxMembers::get()))]
+		pub fn remove_member(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::RemoveOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			let mut members = Members::<T, I>::get();
+			let init_length = members.len();
+			let location = members.binary_search(&who).ok().ok_or(Error::<T, I>::NotMember)?;
+			members.remove(location);
+
+			Members::<T, I>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[], &[who], &members[..]);
+			Self::rejig_prime(&members);
+
+			Self::deposit_event(Event::MemberRemoved);
+			Ok(Some(T::WeightInfo::remove_member(init_length as u32)).into())
+		}
+
+		/// Swap out one member `remove` for another `add`.
+		///
+		/// May only be called from `T::SwapOrigin`.
+		///
+		/// Prime membership is *not* passed from `remove` to `add`, if extant.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::swap_member(T::MaxMembers::get()))]
+		pub fn swap_member(
+			origin: OriginFor<T>,
+			remove: AccountIdLookupOf<T>,
+			add: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::SwapOrigin::ensure_origin(origin)?;
+			let remove = T::Lookup::lookup(remove)?;
+			let add = T::Lookup::lookup(add)?;
+
+			if remove == add {
+				return Ok(().into());
+			}
+
+			let mut members = Members::<T, I>::get();
+			let location = members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
+			members.binary_search(&add).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members[location] = add.clone();
+			members.sort();
+
+			Members::<T, I>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[add], &[remove], &members[..]);
+			Self::rejig_prime(&members);
+
+			Self::deposit_event(Event::MembersSwapped);
+			Ok(Some(T::WeightInfo::swap_member(members.len() as u32)).into())
+		}
+
+		/// 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`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::reset_members(members.len().unique_saturated_into()))]
+		pub fn reset_members(origin: OriginFor<T>, members: Vec<T::AccountId>) -> DispatchResult {
+			T::ResetOrigin::ensure_origin(origin)?;
+
+			let mut members: BoundedVec<T::AccountId, T::MaxMembers> =
+				BoundedVec::try_from(members).map_err(|_| Error::<T, I>::TooManyMembers)?;
+			members.sort();
+			Members::<T, I>::mutate(|m| {
+				T::MembershipChanged::set_members_sorted(&members[..], m);
+				Self::rejig_prime(&members);
+				*m = members;
+			});
+
+			Self::deposit_event(Event::MembersReset);
+			Ok(())
+		}
+
+		/// Swap out the sending member for some other key `new`.
+		///
+		/// May only be called from `Signed` origin of a current member.
+		///
+		/// Prime membership is passed from the origin account to `new`, if extant.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::change_key(T::MaxMembers::get()))]
+		pub fn change_key(
+			origin: OriginFor<T>,
+			new: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let remove = ensure_signed(origin)?;
+			let new = T::Lookup::lookup(new)?;
+
+			if remove == new {
+				return Ok(().into());
+			}
+
+			let mut members = Members::<T, I>::get();
+			let members_length = members.len() as u32;
+			let location = members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
+			members.binary_search(&new).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members[location] = new.clone();
+			members.sort();
+
+			Members::<T, I>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(
+				&[new.clone()],
+				&[remove.clone()],
+				&members[..],
+			);
+
+			if Prime::<T, I>::get() == Some(remove) {
+				Prime::<T, I>::put(&new);
+				T::MembershipChanged::set_prime(Some(new));
+			}
+
+			Self::deposit_event(Event::KeyChanged);
+			Ok(Some(T::WeightInfo::change_key(members_length)).into())
+		}
+
+		/// Set the prime member. Must be a current member.
+		///
+		/// May only be called from `T::PrimeOrigin`.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::set_prime(T::MaxMembers::get()))]
+		pub fn set_prime(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::PrimeOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let members = Members::<T, I>::get();
+			members.binary_search(&who).ok().ok_or(Error::<T, I>::NotMember)?;
+			Prime::<T, I>::put(&who);
+			T::MembershipChanged::set_prime(Some(who));
+			Ok(Some(T::WeightInfo::set_prime(members.len() as u32)).into())
+		}
+
+		/// Remove the prime member if it exists.
+		///
+		/// May only be called from `T::PrimeOrigin`.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::clear_prime())]
+		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: 'static> Pallet<T, I> {
+	/// The current membership, stored as an ordered `Vec`.
+	pub fn members() -> BoundedVec<T::AccountId, T::MaxMembers> {
+		Members::<T, I>::get()
+	}
+
+	/// The current prime member, if one exists.
+	pub fn prime() -> Option<T::AccountId> {
+		Prime::<T, I>::get()
+	}
+
+	fn rejig_prime(members: &[T::AccountId]) {
+		if let Some(prime) = Prime::<T, I>::get() {
+			match members.binary_search(&prime) {
+				Ok(_) => T::MembershipChanged::set_prime(Some(prime)),
+				Err(_) => Prime::<T, I>::kill(),
+			}
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Contains<T::AccountId> for Pallet<T, I> {
+	fn contains(t: &T::AccountId) -> bool {
+		Members::<T, I>::get().binary_search(t).is_ok()
+	}
+}
+
+impl<T: Config> ContainsLengthBound for Pallet<T> {
+	fn min_len() -> usize {
+		0
+	}
+
+	/// Implementation uses a parameter type so calling is cost-free.
+	fn max_len() -> usize {
+		T::MaxMembers::get() as usize
+	}
+}
+
+impl<T: Config<I>, I: 'static> SortedMembers<T::AccountId> for Pallet<T, I> {
+	fn sorted_members() -> Vec<T::AccountId> {
+		Members::<T, I>::get().to_vec()
+	}
+
+	fn count() -> usize {
+		Members::<T, I>::decode_len().unwrap_or(0)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(new_member: &T::AccountId) {
+		use pezframe_support::{assert_ok, traits::EnsureOrigin};
+		let new_member_lookup = T::Lookup::unlookup(new_member.clone());
+
+		if let Ok(origin) = T::AddOrigin::try_successful_origin() {
+			assert_ok!(Pallet::<T, I>::add_member(origin, new_member_lookup,));
+		} else {
+			log::error!(target: LOG_TARGET, "Failed to add `{new_member:?}` in `SortedMembers::add`.")
+		}
+	}
+}

bizinikiwi/pezframe/membership/src/migrations/mod.rs

@@ -0,0 +1,19 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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;

bizinikiwi/pezframe/membership/src/migrations/v4.rs

@@ -0,0 +1,149 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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 super::super::LOG_TARGET;
+use pezsp_io::hashing::twox_128;
+
+use pezframe_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 pezframe_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: pezframe_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: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero();
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v4 for membership with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		pezframe_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 pezframe_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// `pezframe_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);
+
+	if new_pallet_name == old_pallet_name {
+		return;
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key = twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX);
+
+	let mut new_pallet_prefix_iter = pezframe_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|key| Ok(key.to_vec()),
+	);
+
+	// Ensure nothing except maybe the storage_version_key is stored in the new prefix.
+	assert!(new_pallet_prefix_iter.all(|key| key == storage_version_key));
+
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// `pezframe_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);
+
+	if new_pallet_name == old_pallet_name {
+		return;
+	}
+
+	// Assert that nothing remains at the old prefix.
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	let old_pallet_prefix_iter = pezframe_support::storage::KeyPrefixIterator::new(
+		old_pallet_prefix.to_vec(),
+		old_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_pallet_prefix_iter.count(), 0);
+
+	// NOTE: storage_version_key is already in the new prefix.
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let new_pallet_prefix_iter = pezframe_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert!(new_pallet_prefix_iter.count() >= 1);
+
+	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: LOG_TARGET,
+		"{}, prefix: '{}' ==> '{}'",
+		stage,
+		old_pallet_name,
+		new_pallet_name,
+	);
+}

bizinikiwi/pezframe/membership/src/mock.rs

@@ -0,0 +1,117 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+//! Test utilities
+
+use super::*;
+use crate as pezpallet_membership;
+
+use pezsp_runtime::{bounded_vec, BuildStorage};
+
+use pezframe_support::{derive_impl, ord_parameter_types, parameter_types, traits::ConstU32};
+use pezframe_system::EnsureSignedBy;
+
+type Block = pezframe_system::mocking::MockBlock<Test>;
+
+pezframe_support::construct_runtime!(
+	pub enum Test
+	{
+		System: pezframe_system,
+		Membership: pezpallet_membership,
+	}
+);
+
+parameter_types! {
+	pub static Members: Vec<u64> = vec![];
+	pub static Prime: Option<u64> = None;
+}
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Test {
+	type Block = Block;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+	pub const Five: u64 = 5;
+}
+
+pub struct TestChangeMembers;
+impl ChangeMembers<u64> for TestChangeMembers {
+	fn change_members_sorted(incoming: &[u64], outgoing: &[u64], new: &[u64]) {
+		let mut old_plus_incoming = Members::get();
+		old_plus_incoming.extend_from_slice(incoming);
+		old_plus_incoming.sort();
+		let mut new_plus_outgoing = new.to_vec();
+		new_plus_outgoing.extend_from_slice(outgoing);
+		new_plus_outgoing.sort();
+		assert_eq!(old_plus_incoming, new_plus_outgoing);
+
+		Members::set(new.to_vec());
+		Prime::set(None);
+	}
+	fn set_prime(who: Option<u64>) {
+		Prime::set(who);
+	}
+	fn get_prime() -> Option<u64> {
+		Prime::get()
+	}
+}
+
+impl InitializeMembers<u64> for TestChangeMembers {
+	fn initialize_members(members: &[u64]) {
+		MEMBERS.with(|m| *m.borrow_mut() = members.to_vec());
+	}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type AddOrigin = EnsureSignedBy<One, u64>;
+	type RemoveOrigin = EnsureSignedBy<Two, u64>;
+	type SwapOrigin = EnsureSignedBy<Three, u64>;
+	type ResetOrigin = EnsureSignedBy<Four, u64>;
+	type PrimeOrigin = EnsureSignedBy<Five, u64>;
+	type MembershipInitialized = TestChangeMembers;
+	type MembershipChanged = TestChangeMembers;
+	type MaxMembers = ConstU32<10>;
+	type WeightInfo = ();
+}
+
+pub(crate) fn new_test_ext() -> pezsp_io::TestExternalities {
+	let mut t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	// We use default for brevity, but you can configure as desired if needed.
+	pezpallet_membership::GenesisConfig::<Test> {
+		members: bounded_vec![10, 20, 30],
+		..Default::default()
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub(crate) fn new_bench_ext() -> pezsp_io::TestExternalities {
+	pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub(crate) fn clean() {
+	Members::set(vec![]);
+	Prime::set(None);
+}

bizinikiwi/pezframe/membership/src/tests.rs

@@ -0,0 +1,217 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+//! Tests for the module.
+
+use crate as pezpallet_membership;
+use crate::{mock::*, *};
+
+use pezsp_runtime::{bounded_vec, traits::BadOrigin, BuildStorage};
+
+use pezframe_support::{assert_noop, assert_ok, assert_storage_noop, traits::StorageVersion};
+
+#[test]
+fn query_membership_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(crate::Members::<Test>::get(), vec![10, 20, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), vec![10, 20, 30]);
+	});
+}
+
+#[test]
+fn prime_member_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Membership::set_prime(RuntimeOrigin::signed(4), 20), BadOrigin);
+		assert_noop!(
+			Membership::set_prime(RuntimeOrigin::signed(5), 15),
+			Error::<Test, _>::NotMember
+		);
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+		assert_eq!(crate::Prime::<Test>::get(), Some(20));
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+
+		assert_ok!(Membership::clear_prime(RuntimeOrigin::signed(5)));
+		assert_eq!(crate::Prime::<Test>::get(), None);
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+	});
+}
+
+#[test]
+fn add_member_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Membership::add_member(RuntimeOrigin::signed(5), 15), BadOrigin);
+		assert_noop!(
+			Membership::add_member(RuntimeOrigin::signed(1), 10),
+			Error::<Test, _>::AlreadyMember
+		);
+		assert_ok!(Membership::add_member(RuntimeOrigin::signed(1), 15));
+		assert_eq!(crate::Members::<Test>::get(), vec![10, 15, 20, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+	});
+}
+
+#[test]
+fn remove_member_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Membership::remove_member(RuntimeOrigin::signed(5), 20), BadOrigin);
+		assert_noop!(
+			Membership::remove_member(RuntimeOrigin::signed(2), 15),
+			Error::<Test, _>::NotMember
+		);
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+		assert_ok!(Membership::remove_member(RuntimeOrigin::signed(2), 20));
+		assert_eq!(crate::Members::<Test>::get(), vec![10, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+		assert_eq!(crate::Prime::<Test>::get(), None);
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+	});
+}
+
+#[test]
+fn swap_member_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Membership::swap_member(RuntimeOrigin::signed(5), 10, 25), BadOrigin);
+		assert_noop!(
+			Membership::swap_member(RuntimeOrigin::signed(3), 15, 25),
+			Error::<Test, _>::NotMember
+		);
+		assert_noop!(
+			Membership::swap_member(RuntimeOrigin::signed(3), 10, 30),
+			Error::<Test, _>::AlreadyMember
+		);
+
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+		assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 20, 20));
+		assert_eq!(crate::Members::<Test>::get(), vec![10, 20, 30]);
+		assert_eq!(crate::Prime::<Test>::get(), Some(20));
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 10));
+		assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 10, 25));
+		assert_eq!(crate::Members::<Test>::get(), vec![20, 25, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+		assert_eq!(crate::Prime::<Test>::get(), None);
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+	});
+}
+
+#[test]
+fn swap_member_works_that_does_not_change_order() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 10, 5));
+		assert_eq!(crate::Members::<Test>::get(), vec![5, 20, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+	});
+}
+
+#[test]
+fn swap_member_with_identical_arguments_changes_nothing() {
+	new_test_ext().execute_with(|| {
+		assert_storage_noop!(assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 10, 10)));
+	});
+}
+
+#[test]
+fn change_key_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 10));
+		assert_noop!(
+			Membership::change_key(RuntimeOrigin::signed(3), 25),
+			Error::<Test, _>::NotMember
+		);
+		assert_noop!(
+			Membership::change_key(RuntimeOrigin::signed(10), 20),
+			Error::<Test, _>::AlreadyMember
+		);
+		assert_ok!(Membership::change_key(RuntimeOrigin::signed(10), 40));
+		assert_eq!(crate::Members::<Test>::get(), vec![20, 30, 40]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+		assert_eq!(crate::Prime::<Test>::get(), Some(40));
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+	});
+}
+
+#[test]
+fn change_key_works_that_does_not_change_order() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Membership::change_key(RuntimeOrigin::signed(10), 5));
+		assert_eq!(crate::Members::<Test>::get(), vec![5, 20, 30]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+	});
+}
+
+#[test]
+fn change_key_with_same_caller_as_argument_changes_nothing() {
+	new_test_ext().execute_with(|| {
+		assert_storage_noop!(assert_ok!(Membership::change_key(RuntimeOrigin::signed(10), 10)));
+	});
+}
+
+#[test]
+fn reset_members_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+		assert_noop!(
+			Membership::reset_members(RuntimeOrigin::signed(1), bounded_vec![20, 40, 30]),
+			BadOrigin
+		);
+
+		assert_ok!(Membership::reset_members(RuntimeOrigin::signed(4), vec![20, 40, 30]));
+		assert_eq!(crate::Members::<Test>::get(), vec![20, 30, 40]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+		assert_eq!(crate::Prime::<Test>::get(), Some(20));
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+
+		assert_ok!(Membership::reset_members(RuntimeOrigin::signed(4), vec![10, 40, 30]));
+		assert_eq!(crate::Members::<Test>::get(), vec![10, 30, 40]);
+		assert_eq!(MEMBERS.with(|m| m.borrow().clone()), crate::Members::<Test>::get().to_vec());
+		assert_eq!(crate::Prime::<Test>::get(), None);
+		assert_eq!(PRIME.with(|m| *m.borrow()), crate::Prime::<Test>::get());
+	});
+}
+
+#[test]
+#[should_panic(expected = "Members cannot contain duplicate accounts.")]
+fn genesis_build_panics_with_duplicate_members() {
+	pezpallet_membership::GenesisConfig::<Test> {
+		members: bounded_vec![1, 2, 3, 1],
+		phantom: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+}
+
+#[test]
+fn migration_v4() {
+	new_test_ext().execute_with(|| {
+		use pezframe_support::traits::PalletInfo;
+		let old_pallet_name = "OldMembership";
+		let new_pallet_name =
+			<Test as pezframe_system::Config>::PalletInfo::name::<Membership>().unwrap();
+
+		pezframe_support::storage::migration::move_pallet(
+			new_pallet_name.as_bytes(),
+			old_pallet_name.as_bytes(),
+		);
+
+		StorageVersion::new(0).put::<Membership>();
+
+		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);
+	});
+}

bizinikiwi/pezframe/membership/src/weights.rs

@@ -0,0 +1,379 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+// This file is part of Bizinikiwi.
+
+// Copyright (C) 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.
+
+//! Autogenerated weights for `pezpallet_membership`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-02-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `4563561839a5`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024`
+
+// Executed Command:
+// frame-omni-bencher
+// v1
+// benchmark
+// pallet
+// --extrinsic=*
+// --runtime=target/production/wbuild/kitchensink-runtime/kitchensink_runtime.wasm
+// --pallet=pezpallet_membership
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/HEADER-APACHE2
+// --output=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/pezframe/membership/src/weights.rs
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --template=bizinikiwi/.maintain/frame-weight-template.hbs
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+// --genesis-builder-policy=none
+// --exclude-pallets=pezpallet_xcm,pezpallet_xcm_benchmarks::fungible,pezpallet_xcm_benchmarks::generic,pezpallet_nomination_pools,pezpallet_remark,pezpallet_transaction_storage,pezpallet_election_provider_multi_block,pezpallet_election_provider_multi_block::signed,pezpallet_election_provider_multi_block::unsigned,pezpallet_election_provider_multi_block::verifier
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+#![allow(dead_code)]
+
+use pezframe_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pezpallet_membership`.
+pub trait WeightInfo {
+	fn add_member(m: u32, ) -> Weight;
+	fn remove_member(m: u32, ) -> Weight;
+	fn swap_member(m: u32, ) -> Weight;
+	fn reset_members(m: u32, ) -> Weight;
+	fn change_key(m: u32, ) -> Weight;
+	fn set_prime(m: u32, ) -> Weight;
+	fn clear_prime() -> Weight;
+}
+
+/// Weights for `pezpallet_membership` using the Bizinikiwi node and recommended hardware.
+pub struct BizinikiwiWeight<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo for BizinikiwiWeight<T> {
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 99]`.
+	fn add_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 8_764_000 picoseconds.
+		Weight::from_parts(9_308_742, 4687)
+			// Standard Error: 488
+			.saturating_add(Weight::from_parts(26_797, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[2, 100]`.
+	fn remove_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_017_000 picoseconds.
+		Weight::from_parts(12_554_406, 4687)
+			// Standard Error: 245
+			.saturating_add(Weight::from_parts(24_524, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[2, 100]`.
+	fn swap_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_318_000 picoseconds.
+		Weight::from_parts(12_625_174, 4687)
+			// Standard Error: 464
+			.saturating_add(Weight::from_parts(39_371, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn reset_members(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 11_503_000 picoseconds.
+		Weight::from_parts(12_733_911, 4687)
+			// Standard Error: 563
+			.saturating_add(Weight::from_parts(107_985, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn change_key(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_367_000 picoseconds.
+		Weight::from_parts(12_884_989, 4687)
+			// Standard Error: 768
+			.saturating_add(Weight::from_parts(43_064, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalMembership::Prime` (r:0 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn set_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (32 ±0)`
+		//  Estimated: `4687 + m * (32 ±0)`
+		// Minimum execution time: 4_060_000 picoseconds.
+		Weight::from_parts(4_409_075, 4687)
+			// Standard Error: 136
+			.saturating_add(Weight::from_parts(13_153, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Prime` (r:0 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn clear_prime() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_843_000 picoseconds.
+		Weight::from_parts(1_972_000, 0)
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 99]`.
+	fn add_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 8_764_000 picoseconds.
+		Weight::from_parts(9_308_742, 4687)
+			// Standard Error: 488
+			.saturating_add(Weight::from_parts(26_797, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[2, 100]`.
+	fn remove_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_017_000 picoseconds.
+		Weight::from_parts(12_554_406, 4687)
+			// Standard Error: 245
+			.saturating_add(Weight::from_parts(24_524, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[2, 100]`.
+	fn swap_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_318_000 picoseconds.
+		Weight::from_parts(12_625_174, 4687)
+			// Standard Error: 464
+			.saturating_add(Weight::from_parts(39_371, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn reset_members(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 11_503_000 picoseconds.
+		Weight::from_parts(12_733_911, 4687)
+			// Standard Error: 563
+			.saturating_add(Weight::from_parts(107_985, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Proposals` (r:1 w:0)
+	/// Proof: `TechnicalCommittee::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalMembership::Prime` (r:1 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Members` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn change_key(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `73 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 12_367_000 picoseconds.
+		Weight::from_parts(12_884_989, 4687)
+			// Standard Error: 768
+			.saturating_add(Weight::from_parts(43_064, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Members` (r:1 w:0)
+	/// Proof: `TechnicalMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalMembership::Prime` (r:0 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `m` is `[1, 100]`.
+	fn set_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (32 ±0)`
+		//  Estimated: `4687 + m * (32 ±0)`
+		// Minimum execution time: 4_060_000 picoseconds.
+		Weight::from_parts(4_409_075, 4687)
+			// Standard Error: 136
+			.saturating_add(Weight::from_parts(13_153, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: `TechnicalMembership::Prime` (r:0 w:1)
+	/// Proof: `TechnicalMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	/// Storage: `TechnicalCommittee::Prime` (r:0 w:1)
+	/// Proof: `TechnicalCommittee::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn clear_prime() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_843_000 picoseconds.
+		Weight::from_parts(1_972_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}