feat(mainnet): add gov: collective, membership, motion

Cargo.toml

@@ -68,6 +68,7 @@ substrate-wasm-builder = { git = "https://github.com/paritytech/polkadot-sdk", b
 
 # Local
 pallet-api = { path = "pallets/api", default-features = false }
+pallet-motion = { path = "pallets/motion", default-features = false }
 pallet-nfts = { path = "pallets/nfts", default-features = false }
 pop-chain-extension = { path = "./extension", default-features = false }
 pop-primitives = { path = "./primitives", default-features = false }
@@ -90,7 +91,9 @@ pallet-assets = { git = "https://github.com/paritytech/polkadot-sdk", branch = "
 pallet-aura = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-authorship = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
+pallet-collective = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-contracts = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
+pallet-membership = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-message-queue = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-multisig = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }
 pallet-nft-fractionalization = { git = "https://github.com/paritytech/polkadot-sdk", branch = "stable2412", default-features = false }

networks/mainnet.toml

@@ -34,6 +34,15 @@ balances = [
     ["5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL", 10000000000000000],
 ]
 
+[parachains.genesis_overrides.councilMembership]
+members = [
+    # Dev accounts
+    "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
+    "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty",
+    "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y",
+    "5DAAnrj7VHTznn2AWBemMuyBwZWs6FNFjdyVXUeYum3PTXFy",
+]
+
 [[parachains.collators]]
 name = "pop"
 rpc_port = 9944

node/src/chain_spec.rs

@@ -198,6 +198,8 @@ pub fn mainnet_chain_spec(relay: Relay) -> MainnetChainSpec {
 		],
 		sudo_account_id,
 		para_id.into(),
+		// councillors
+		vec![],
 	))
 	.with_protocol_id("pop")
 	.with_properties(properties)
@@ -208,6 +210,7 @@ fn mainnet_genesis(
 	invulnerables: Vec<(AccountId, AuraId)>,
 	root: AccountId,
 	id: ParaId,
+	councillors: Vec<AccountId>,
 ) -> serde_json::Value {
 	use pop_runtime_mainnet::EXISTENTIAL_DEPOSIT;
 
@@ -238,7 +241,10 @@ fn mainnet_genesis(
 		"polkadotXcm": {
 			"safeXcmVersion": Some(SAFE_XCM_VERSION),
 		},
-		"sudo": { "key": Some(root) }
+		"sudo": { "key": Some(root) },
+		"councilMembership": {
+			"members": councillors,
+		}
 	})
 }
 

pallets/motion/Cargo.toml

@@ -0,0 +1,51 @@
+[package]
+authors = [ "Substrate DevHub <https://github.com/substrate-developer-hub>" ]
+description = "FRAME pallet to wrap council calls providing root origin to the council."
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+name = "pallet-motion"
+publish = false
+repository = { workspace = true }
+version = "4.0.0-dev"
+
+[package.metadata.docs.rs]
+targets = [ "x86_64-unknown-linux-gnu" ]
+
+[dependencies]
+codec = { workspace = true, default-features = false, features = [
+	"derive",
+] }
+frame-benchmarking = { workspace = true, default-features = false, optional = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true, default-features = false }
+pallet-collective = { workspace = true, default-features = false }
+scale-info = { workspace = true, default-features = false, features = [
+	"derive",
+] }
+sp-runtime = { workspace = true, default-features = false }
+
+[dev-dependencies]
+pallet-balances = { workspace = true, default-features = false }
+sp-core = { workspace = true, default-features = false }
+sp-io = { workspace = true, default-features = false }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"pallet-collective/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-collective/std",
+	"scale-info/std",
+	"sp-runtime/std",
+]
+try-runtime = [ "frame-support/try-runtime" ]

pallets/motion/README.md

@@ -0,0 +1,38 @@
+# Motion Pallet
+
+`pallet-motion` enables councils (`pallet-collective`) to make root-origin calls by providing three configurable origins:
+- `SimpleMajority` (1/2)
+- `SuperMajority` (2/3)
+- `Unanimous` (1/1)
+
+It is composed of three associated extrinsics, one for each origin:
+- `simple_majority`
+    - Dispatches the call if and only if the number of votes is greater than `SimpleMajority`.
+- `super_majority`
+    - Dispatches the call if and only if the number of votes is greater than or equal to `SuperMajority`.
+- `unanimous`
+    - Dispatches the call if and only if all collective members have voted yes.
+
+
+## Configuration
+
+You can configure `pallet-motion` in combination with `pallet-collective` the following way:
+
+```rust
+type CouncilCollective = pallet_collective::Instance1;
+impl pallet_motion::Config for Runtime {
+	// ---
+	type SimpleMajorityOrigin =
+		pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>;
+	type SuperMajorityOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 2, 3>;
+	type UnanimousOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 1>;
+}
+```
+
+---
+
+### Credit:
+
+Original source at: https://github.com/Watr-Protocol/watr/tree/main/pallets/motion

pallets/motion/src/benchmarking.rs

@@ -0,0 +1,51 @@
+//! Benchmarking setup for pallet-motion
+
+use frame_benchmarking::v2::*;
+use frame_support::traits::EnsureOrigin;
+
+use super::*;
+#[allow(unused)]
+use crate::Pallet as Motion;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+#[benchmarks(
+where
+	<T as Config>::RuntimeCall: From<frame_system::Call<T>>,
+)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn simple_majority() {
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let origin = <T as Config>::SimpleMajorityOrigin::try_successful_origin().unwrap();
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, Box::new(call));
+
+		assert_last_event::<T>(Event::DispatchSimpleMajority { motion_result: Ok(()) }.into())
+	}
+
+	#[benchmark]
+	fn super_majority() {
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let origin = <T as Config>::SuperMajorityOrigin::try_successful_origin().unwrap();
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, Box::new(call));
+
+		assert_last_event::<T>(Event::DispatchSuperMajority { motion_result: Ok(()) }.into())
+	}
+
+	#[benchmark]
+	fn unanimous() {
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let origin = <T as Config>::UnanimousOrigin::try_successful_origin().unwrap();
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, Box::new(call));
+
+		assert_last_event::<T>(Event::DispatchUnanimous { motion_result: Ok(()) }.into())
+	}
+	impl_benchmark_test_suite!(Motion, crate::mock::new_test_ext(), crate::mock::Test);
+}

pallets/motion/src/lib.rs

@@ -0,0 +1,154 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub mod weights;
+pub use pallet::*;
+use sp_runtime::DispatchResult;
+pub use weights::WeightInfo;
+
+extern crate alloc;
+use alloc::{boxed::Box, vec};
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::{
+		dispatch::GetDispatchInfo, pallet_prelude::*, traits::UnfilteredDispatchable,
+	};
+	use frame_system::pallet_prelude::*;
+
+	use super::{DispatchResult, *};
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// The runtime call type.
+		type RuntimeCall: Parameter
+			+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo;
+		/// Origin that can act as `Root` origin if a collective has achieved a simple majority
+		/// consensus.
+		type SimpleMajorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		/// Origin that can act as `Root` origin if a collective has achieved a super majority
+		/// consensus.
+		type SuperMajorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		/// Origin that can act as `Root` origin if a collective has achieved a unanimous consensus.
+		type UnanimousOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A [SimpleMajorityOrigin] motion was executed. [motion_result] contains the call result
+		DispatchSimpleMajority { motion_result: DispatchResult },
+		/// A [SuperMajorityOrigin] motion was executed. [motion_result] contains the call result
+		DispatchSuperMajority { motion_result: DispatchResult },
+		/// A [UnanimousOrigin] motion was executed. [motion_result] contains the call result
+		DispatchUnanimous { motion_result: DispatchResult },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Ensures the simple majority is met and dispatches a call with `Root` origin.
+		///
+		/// # <weight>
+		/// - O(1).
+		/// - Limited storage reads.
+		/// - One DB write (event).
+		/// - Weight of derivative `call` execution + 10,000.
+		/// # </weight>
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(T::WeightInfo::simple_majority().saturating_add(dispatch_info.call_weight), dispatch_info.class)
+		})]
+		#[pallet::call_index(1)]
+		pub fn simple_majority(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			T::SimpleMajorityOrigin::ensure_origin(origin)?;
+
+			let motion_result = Self::do_dispatch(*call);
+			Self::deposit_event(Event::DispatchSimpleMajority { motion_result });
+
+			Ok(Pays::No.into())
+		}
+
+		/// Ensures the super majority is met and dispatches a call with `Root` origin.
+		///
+		/// # <weight>
+		/// - O(1).
+		/// - Limited storage reads.
+		/// - One DB write (event).
+		/// - Weight of derivative `call` execution + 10,000.
+		/// # </weight>
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(T::WeightInfo::super_majority().saturating_add(dispatch_info.call_weight), dispatch_info.class)
+		})]
+		#[pallet::call_index(2)]
+		pub fn super_majority(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			T::SuperMajorityOrigin::ensure_origin(origin)?;
+
+			let motion_result = Self::do_dispatch(*call);
+			Self::deposit_event(Event::DispatchSuperMajority { motion_result });
+
+			Ok(Pays::No.into())
+		}
+
+		/// Ensures unanimous voting is met and dispatches a call with `Root` origin.
+		///
+		/// # <weight>
+		/// - O(1).
+		/// - Limited storage reads.
+		/// - One DB write (event).
+		/// - Weight of derivative `call` execution + 10,000.
+		/// # </weight>
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(T::WeightInfo::unanimous().saturating_add(dispatch_info.call_weight), dispatch_info.class)
+		})]
+		#[pallet::call_index(3)]
+		pub fn unanimous(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			T::UnanimousOrigin::ensure_origin(origin)?;
+
+			let motion_result = Self::do_dispatch(*call);
+			Self::deposit_event(Event::DispatchUnanimous { motion_result });
+
+			Ok(Pays::No.into())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// Helper to actually dispatch RuntimeCall.
+		///
+		/// Should only be called after the origin is ensured.
+		///
+		/// Returns the `DispatchResult` from the dispatched call.
+		fn do_dispatch(call: <T as Config>::RuntimeCall) -> DispatchResult {
+			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
+			res.map(|_| ()).map_err(|e| e.error)
+		}
+	}
+}