Struct pallet_collective::pallet::Pallet

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

The pallet implementing the on-chain logic.

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.

Requires root origin.

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.

Weight

• 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)
• DB:
  • 1 storage mutation (codec O(M) read, O(N) write) for reading and writing the members
  • 1 storage read (codec O(P)) for reading the proposals
  • P storage mutations (codec O(M)) for updating the votes for each proposal
  • 1 storage write (codec O(1)) for deleting the old prime and setting the new one

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.

Weight

• O(M + P) where M members-count (code-bounded) and P complexity of dispatching proposal
• DB: 1 read (codec O(M)) + DB access of proposal
• 1 event

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.

Weight

• 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)
• DB:
  • 1 storage read is_member (codec O(M))
  • 1 storage read ProposalOf::contains_key (codec O(1))
  • DB accesses influenced by threshold:
    • EITHER storage accesses done by proposal (threshold < 2)
    • OR proposal insertion (threshold <= 2)
      • 1 storage mutation Proposals (codec O(P2))
      • 1 storage mutation ProposalCount (codec O(1))
      • 1 storage write ProposalOf (codec O(B))
      • 1 storage write Voting (codec O(M))
  • 1 event

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.

Weight

• O(M) where M is members-count (code- and governance-bounded)
• DB:
  • 1 storage read Members (codec O(M))
  • 1 storage mutation Voting (codec O(M))
• 1 event

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.

Weight

• 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)
• DB:
• 2 storage reads (Members: codec O(M), Prime: codec O(1))
• 3 mutations (Voting: codec O(M), ProposalOf: codec O(B), Proposals: codec O(P2))
• any mutations done while executing proposal (P1)
• up to 3 events

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.

Parameters:

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

Complexity: O(P) where P is the number of max proposals DB Weight:

• Reads: Proposals
• Writes: Voting, Proposals, ProposalOf

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

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

The hashes of the active 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>,

Actual proposal for a given hash, if it’s current.

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

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

Votes on a given proposal, if it is ongoing.

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

pub fn proposal_count() -> u32

Proposals so far.

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

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

The current members of the collective. This is stored sorted (just by value).

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

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

The prime member that helps determine the default vote behavior in case of absentations.

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(
    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, I: 'static> Benchmarking for Pallet<T, I>where
    T: Config + Config<I>,

fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>

Get the benchmarks available for this pallet. Generally there is one benchmark per extrinsic, so these are sometimes just called “extrinsics”.

fn run_benchmark(
    extrinsic: &[u8],
    c: &[(BenchmarkParameter, u32)],
    whitelist: &[TrackedStorageKey],
    verify: bool,
    internal_repeats: u32
) -> Result<Vec<BenchmarkResult>, BenchmarkError>

Run the benchmarks for this pallet.

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

type Call = 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.

Weight

• O(MP + N)
  • where M old-members-count (governance-bounded)
  • where N new-members-count (governance-bounded)
  • where P proposals-count
• DB:
  • 1 storage read (codec O(P)) for reading the proposals
  • P storage mutations for updating the votes (codec O(M))
  • 1 storage write (codec O(N)) for storing the new members
  • 1 storage write (codec O(1)) for deleting the old prime

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> GetStorageVersion for Pallet<T, I>

fn current_storage_version() -> StorageVersion

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>::BlockNumber> for Pallet<T, I>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

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

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn on_initialize(_n: BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn try_state(_n: BlockNumber) -> Result<(), &'static str>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

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()

Run integrity test.

impl<T: Config<I>, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>

fn offchain_worker(n: <T as Config>::BlockNumber)

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

impl<T: Config<I>, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

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>::BlockNumber> for Pallet<T, I>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config<I>, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

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

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a 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> TryState<<T as Config>::BlockNumber> for Pallet<T, I>

fn try_state(
    n: <T as Config>::BlockNumber,
    _s: TryStateSelect
) -> Result<(), &'static str>

Execute the state checks.

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