Struct pallet_collective_mangata::pallet::Pallet

pub struct Pallet<T, I = ()>(_);

The Pallet struct, the main type that implements traits and standalone functions within the pallet.

Implementations

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn set_members( origin: OriginFor<T>, new_members: Vec<T::AccountId>, prime: Option<T::AccountId>, old_count: MemberCount ) -> DispatchResultWithPostInfo

Set the collective’s membership.

• new_members: The new member list. Be nice to the chain and provide it sorted.
• prime: The prime member whose vote sets the default.
• old_count: The upper bound for the previous number of members in storage. Used for weight estimation.

The dispatch of this call must be SetMembersOrigin.

NOTE: Does not enforce the expected MaxMembers limit on the amount of members, but the weight estimations rely on it to estimate dispatchable weight.

WARNING:

The pallet-collective can also be managed by logic outside of the pallet through the implementation of the trait ChangeMembers. Any call to set_members must be careful that the member set doesn’t get out of sync with other logic managing the member set.

Complexity:

• O(MP + N) where:
  • M old-members-count (code- and governance-bounded)
  • N new-members-count (code- and governance-bounded)
  • P proposals-count (code-bounded)

pub fn execute( origin: OriginFor<T>, proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32 ) -> DispatchResultWithPostInfo

Dispatch a proposal from a member using the Member origin.

Origin must be a member of the collective.

Complexity:

• O(B + M + P) where:
• B is proposal size in bytes (length-fee-bounded)
• M members-count (code-bounded)
• P complexity of dispatching proposal

pub fn propose( origin: OriginFor<T>, threshold: MemberCount, proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32 ) -> DispatchResultWithPostInfo

Add a new proposal to either be voted on or executed directly.

Requires the sender to be member.

threshold determines whether proposal is executed directly (threshold < 2) or put up for voting.

Complexity

• O(B + M + P1) or O(B + M + P2) where:
  • B is proposal size in bytes (length-fee-bounded)
  • M is members-count (code- and governance-bounded)
  • branching is influenced by threshold where:
    • P1 is proposal execution complexity (threshold < 2)
    • P2 is proposals-count (code-bounded) (threshold >= 2)

pub fn vote( origin: OriginFor<T>, proposal: T::Hash, index: ProposalIndex, approve: bool ) -> DispatchResultWithPostInfo

Add an aye or nay vote for the sender to the given proposal.

Requires the sender to be a member.

Transaction fees will be waived if the member is voting on any particular proposal for the first time and the call is successful. Subsequent vote changes will charge a fee.

Complexity

• O(M) where M is members-count (code- and governance-bounded)

pub fn disapprove_proposal( origin: OriginFor<T>, proposal_hash: T::Hash ) -> DispatchResultWithPostInfo

Disapprove a proposal, close, and remove it from the system, regardless of its current state.

Must be called by the Root origin or a foundation account.

Parameters:

• proposal_hash: The hash of the proposal that should be disapproved.

Complexity

O(P) where P is the number of max proposals

pub fn close( origin: OriginFor<T>, proposal_hash: T::Hash, index: ProposalIndex, proposal_weight_bound: Weight, length_bound: u32 ) -> DispatchResultWithPostInfo

Close a vote that is either approved, disapproved or whose voting period has ended.

May be called by any signed account in order to finish voting and close the proposal.

If called before the end of the voting period it will only close the vote if it is has enough votes to be approved or disapproved.

If called after the end of the voting period abstentions are counted as rejections unless there is a prime member set and the prime member cast an approval.

If the close operation completes successfully with disapproval, the transaction fee will be waived. Otherwise execution of the approved operation will be charged to the caller.

• proposal_weight_bound: The maximum amount of weight consumed by executing the closed proposal.
• length_bound: The upper bound for the length of the proposal in storage. Checked via storage::read so it is size_of::<u32>() == 4 larger than the pure length.

Complexity

• O(B + M + P1 + P2) where:
  • B is proposal size in bytes (length-fee-bounded)
  • M is members-count (code- and governance-bounded)
  • P1 is the complexity of proposal preimage.
  • P2 is proposal-count (code-bounded)

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn proposals() -> BoundedVec<T::Hash, T::MaxProposals>

An auto-generated getter for Proposals.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn proposal_of<KArg>(k: KArg) -> Option<<T as Config<I>>::Proposal>where KArg: EncodeLike<T::Hash>,

An auto-generated getter for ProposalOf.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn proposal_proposed_time<KArg>(k: KArg) -> Option<BlockNumberFor<T>>where KArg: EncodeLike<T::Hash>,

An auto-generated getter for ProposalProposedTime.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn voting<KArg>(k: KArg) -> Option<Votes<T::AccountId, BlockNumberFor<T>>>where KArg: EncodeLike<T::Hash>,

An auto-generated getter for Voting.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn proposal_count() -> u32

An auto-generated getter for ProposalCount.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn members() -> Vec<T::AccountId>

An auto-generated getter for Members.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn prime() -> Option<T::AccountId>

An auto-generated getter for Prime.

impl<T: Config<I>, I: 'static> Pallet<T, I>

pub fn is_member(who: &T::AccountId) -> bool

Check whether who is a member of the collective.

pub fn do_propose_execute( proposal: Box<<T as Config<I>>::Proposal>, length_bound: MemberCount ) -> Result<(u32, DispatchResultWithPostInfo), DispatchError>

Execute immediately when adding a new proposal.

pub fn do_propose_proposed( who: T::AccountId, threshold: MemberCount, proposal: Box<<T as Config<I>>::Proposal>, length_bound: MemberCount ) -> Result<(u32, u32), DispatchError>

Add a new proposal to be voted.

pub fn do_vote( who: T::AccountId, proposal: T::Hash, index: ProposalIndex, approve: bool ) -> Result<bool, DispatchError>

Add an aye or nay vote for the member to the given proposal, returns true if it’s the first vote of the member in the motion

pub fn do_close( caller: T::AccountId, proposal_hash: T::Hash, index: ProposalIndex, proposal_weight_bound: Weight, length_bound: u32 ) -> DispatchResultWithPostInfo

Close a vote that is either approved, disapproved or whose voting period has ended.

pub fn do_disapprove_proposal(proposal_hash: T::Hash) -> u32

Removes a proposal from the pallet, and deposit the Disapproved event.

Trait Implementations

impl<T: Config<I>, I: 'static> Callable<T> for Pallet<T, I>

type RuntimeCall = Call<T, I>

impl<T: Config<I>, I: 'static> ChangeMembers<<T as Config>::AccountId> for Pallet<T, I>

fn change_members_sorted( _incoming: &[T::AccountId], outgoing: &[T::AccountId], new: &[T::AccountId] )

Update the members of the collective. Votes are updated and the prime is reset.

NOTE: Does not enforce the expected MaxMembers limit on the amount of members, but the weight estimations rely on it to estimate dispatchable weight.

Complexity

• O(MP + N)
  • where M old-members-count (governance-bounded)
  • where N new-members-count (governance-bounded)
  • where P proposals-count

fn set_prime(prime: Option<T::AccountId>)

Set the prime member.

fn get_prime() -> Option<T::AccountId>

Get the current prime.

fn change_members( incoming: &[AccountId], outgoing: &[AccountId], new: Vec<AccountId, Global> )

A number of members incoming just joined the set and replaced some outgoing ones. The new set is given by new, and need not be sorted.

fn set_members_sorted(new_members: &[AccountId], old_members: &[AccountId])

Set the new members; they must already be sorted. This will compute the diff and use it to call change_members_sorted.

fn compute_members_diff_sorted( new_members: &[AccountId], old_members: &[AccountId] ) -> (Vec<AccountId, Global>, Vec<AccountId, Global>)

Compute diff between new and old members; they must already be sorted.

impl<T, I> Clone for Pallet<T, I>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, I> Debug for Pallet<T, I>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> GetMembers<<T as Config>::AccountId> for Pallet<T, I>

fn get_members() -> Vec<T::AccountId>

impl<T: Config<I>, I: 'static> GetStorageVersion for Pallet<T, I>

type CurrentStorageVersion = StorageVersion

This will be filled out by the pallet macro.

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config<I>, I: 'static> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

fn on_initialize(_n: BlockNumber) -> Weight

Block initialization hook. This is called at the very beginning of block execution.

fn on_finalize(_n: BlockNumber)

Block finalization hook. This is called at the very end of block execution.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before Hooks::on_finalize).

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are dispatched as separate threads, and entirely independent of the main wasm runtime.

fn integrity_test()

Check the integrity of this pallet’s configuration.

impl<T: Config<I>, I: 'static> InitializeMembers<<T as Config>::AccountId> for Pallet<T, I>

fn initialize_members(members: &[T::AccountId])

Initialize the members to the given members.

impl<T: Config<I>, I: 'static> IntegrityTest for Pallet<T, I>

fn integrity_test()

See Hooks::integrity_test.

impl<T: Config<I>, I: 'static> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced).

impl<T: Config<I>, I: 'static> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

fn on_finalize(n: BlockNumberFor<T>)

See Hooks::on_finalize.

impl<T: Config<I>, I: 'static> OnGenesis for Pallet<T, I>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config<I>, I: 'static> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See Hooks::on_idle.

impl<T: Config<I>, I: 'static> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See Hooks::on_initialize.

impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Pallet<T, I>

fn on_runtime_upgrade() -> Weight

See Hooks::on_runtime_upgrade.

impl<T: Config<I>, I: 'static> PalletInfoAccess for Pallet<T, I>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T: Config<I>, I: 'static> PalletsInfoAccess for Pallet<T, I>

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T, I> PartialEq<Pallet<T, I>> for Pallet<T, I>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config<I>, I: 'static> StorageInfoTrait for Pallet<T, I>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config<I>, I: 'static> WhitelistedStorageKeys for Pallet<T, I>

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that should be whitelisted during benchmarking. This means that those keys will be excluded from the benchmarking performance calculation.

impl<T, I> Eq for Pallet<T, I>