Enum pallet_collective::pallet::Call

pub enum Call<T: Config<I>, I: 'static = ()> {
    set_members {
        new_members: Vec<T::AccountId>,
        prime: Option<T::AccountId>,
        old_count: MemberCount,
    },
    execute {
        proposal: Box<<T as Config<I>>::Proposal>,
        length_bound: u32,
    },
    propose {
        threshold: MemberCount,
        proposal: Box<<T as Config<I>>::Proposal>,
        length_bound: u32,
    },
    vote {
        proposal: T::Hash,
        index: ProposalIndex,
        approve: bool,
    },
    disapprove_proposal {
        proposal_hash: T::Hash,
    },
    close {
        proposal_hash: T::Hash,
        index: ProposalIndex,
        proposal_weight_bound: Weight,
        length_bound: u32,
    },
    kill {
        proposal_hash: T::Hash,
    },
    release_proposal_cost {
        proposal_hash: T::Hash,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

set_members

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)

Fields

new_members: Vec<T::AccountId>

prime: Option<T::AccountId>

old_count: MemberCount

execute

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

Fields

proposal: Box<<T as Config<I>>::Proposal>

length_bound: u32

propose

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)

Fields

threshold: MemberCount

proposal: Box<<T as Config<I>>::Proposal>

length_bound: u32

vote

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)

Fields

proposal: T::Hash

index: ProposalIndex

approve: bool

disapprove_proposal

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

Fields

proposal_hash: T::Hash

close

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)

Fields

proposal_hash: T::Hash

index: ProposalIndex

proposal_weight_bound: Weight

length_bound: u32

kill

Disapprove the proposal and burn the cost held for storing this proposal.

Parameters:

• origin: must be the KillOrigin.
• proposal_hash: The hash of the proposal that should be killed.

Emits Killed and ProposalCostBurned if any cost was held for a given proposal.

Fields

proposal_hash: T::Hash

release_proposal_cost

Release the cost held for storing a proposal once the given proposal is completed.

If there is no associated cost for the given proposal, this call will have no effect.

Parameters:

• origin: must be Signed or Root.
• proposal_hash: The hash of the proposal.

Emits ProposalCostReleased if any cost held for a given proposal.

Fields

proposal_hash: T::Hash

Implementations

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

pub fn new_call_variant_set_members( new_members: Vec<T::AccountId>, prime: Option<T::AccountId>, old_count: MemberCount, ) -> Self

Create a call with the variant set_members.

pub fn new_call_variant_execute( proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32, ) -> Self

Create a call with the variant execute.

pub fn new_call_variant_propose( threshold: MemberCount, proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32, ) -> Self

Create a call with the variant propose.

pub fn new_call_variant_vote( proposal: T::Hash, index: ProposalIndex, approve: bool, ) -> Self

Create a call with the variant vote.

pub fn new_call_variant_disapprove_proposal(proposal_hash: T::Hash) -> Self

Create a call with the variant disapprove_proposal.

pub fn new_call_variant_close( proposal_hash: T::Hash, index: ProposalIndex, proposal_weight_bound: Weight, length_bound: u32, ) -> Self

Create a call with the variant close.

pub fn new_call_variant_kill(proposal_hash: T::Hash) -> Self

Create a call with the variant kill.

pub fn new_call_variant_release_proposal_cost(proposal_hash: T::Hash) -> Self

Create a call with the variant release_proposal_cost.

Trait Implementations

impl<T: Config<I>, I: 'static> CheckIfFeeless for Call<T, I>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

impl<T: Config<I>, I: 'static> Clone for Call<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: Config<I>, I: 'static> Debug for Call<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config<I>, I: 'static> Encode for Call<T, I>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config<I>, I: 'static> GetCallIndex for Call<T, I>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

impl<T: Config<I>, I: 'static> GetCallName for Call<T, I>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names in the same order as [GetCallIndex].

impl<T: Config<I>, I: 'static> GetDispatchInfo for Call<T, I>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config<I>, I: 'static> PartialEq for Call<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, I> TypeInfo for Call<T, I>

where PhantomData<(T, I)>: TypeInfo + 'static, Vec<T::AccountId>: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, Box<<T as Config<I>>::Proposal>: TypeInfo + 'static, T::Hash: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = Call<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> UnfilteredDispatchable for Call<T, I>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

impl<T: Config<I>, I: 'static> EncodeLike for Call<T, I>

impl<T: Config<I>, I: 'static> Eq for Call<T, I>