Type Alias moonbeam_runtime::OpenTechCommitteeCollective

pub type OpenTechCommitteeCollective = Pallet<Runtime, Instance4>;

Aliased Type

struct OpenTechCommitteeCollective(/* private fields */);

Implementations

impl<T, I> Pallet<T, I>

where T: Config<I>, I: 'static,

pub fn set_members( origin: <T as Config>::RuntimeOrigin, new_members: Vec<<T as Config>::AccountId>, prime: Option<<T as Config>::AccountId>, old_count: u32 ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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: <T as Config>::RuntimeOrigin, proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32 ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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: <T as Config>::RuntimeOrigin, threshold: u32, proposal: Box<<T as Config<I>>::Proposal>, length_bound: u32 ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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: <T as Config>::RuntimeOrigin, proposal: <T as Config>::Hash, index: u32, approve: bool ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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: <T as Config>::RuntimeOrigin, proposal_hash: <T as Config>::Hash ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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

pub fn close( origin: <T as Config>::RuntimeOrigin, proposal_hash: <T as Config>::Hash, index: u32, proposal_weight_bound: Weight, length_bound: u32 ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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

where T: Config<I>, I: 'static,

pub fn is_member(who: &<T as Config>::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: u32 ) -> Result<(u32, Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>), DispatchError>

Execute immediately when adding a new proposal.

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

Add a new proposal to be voted.

pub fn do_vote( who: <T as Config>::AccountId, proposal: <T as Config>::Hash, index: u32, 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 as Config>::Hash, index: u32, proposal_weight_bound: Weight, length_bound: u32 ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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

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

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

Trait Implementations

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

where T: Config<I>, I: 'static,

fn on_finalize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number )

See [Hooks::on_finalize].

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

where T: Config<I>, I: 'static,

type RuntimeCall = Call<T, I>

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

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

Formats the value using the given formatter.

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

where T: Config<I>, I: 'static,

fn initialize_members(members: &[<T as Config>::AccountId])

Initialize the members to the given members.

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

where T: Config<I>, I: 'static,

fn on_genesis()

Something that should happen at genesis.

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

where T: Config<I>, I: 'static,

fn change_members_sorted( _incoming: &[<T as Config>::AccountId], outgoing: &[<T as Config>::AccountId], new: &[<T as Config>::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 as Config>::AccountId>)

Set the prime member.

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

Get the current prime.

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

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>, Vec<AccountId>)

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

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

where T: Config<I>, I: 'static,

fn on_poll( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, weight: &mut WeightMeter )

Code to execute every now and then at the beginning of the block after inherent application.

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

where T: Config<I>, I: 'static,

fn storage_info() -> Vec<StorageInfo>

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

where T: Config<I>, I: 'static,

fn integrity_test()

See [Hooks::integrity_test].

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

where T: Config<I>, I: 'static,

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.

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

where T: Config<I>, I: 'static,

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 name_hash() -> [u8; 16]

Two128 hash of name.

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

where T: Config<I>, I: 'static,

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> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

where T: Config<I>, I: 'static,

fn offchain_worker( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number )

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

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

where T: Config<I>, I: 'static,

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].

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

where T: Config<I>, I: 'static,

fn on_idle( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, remaining_weight: Weight ) -> Weight

See [Hooks::on_idle].

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

where T: Config<I>, I: 'static,

type InCodeStorageVersion = StorageVersion

This type is generated by the pallet macro.

fn in_code_storage_version( ) -> <Pallet<T, I> as GetStorageVersion>::InCodeStorageVersion

Returns the in-code storage version as specified in the storage_version attribute, or [NoStorageVersionSet] if the attribute is missing.

fn on_chain_storage_version() -> StorageVersion

Returns the storage version of the pallet as last set in the actual on-chain storage.

fn current_storage_version() -> Self::InCodeStorageVersion

👎Deprecated: This method has been renamed to in_code_storage_version and will be removed after March 2024.

DEPRECATED: Use [Self::current_storage_version] instead.

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

where T: Config<I>, I: 'static,

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_poll(_n: BlockNumber, _weight: &mut WeightMeter)

A hook to run logic after inherent application.

fn on_runtime_upgrade() -> Weight

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

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 blockchain execution.

fn integrity_test()

Check the integrity of this pallet’s configuration.

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

fn eq(&self, other: &Pallet<T, I>) -> 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> Eq for Pallet<T, I>

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

where T: Config<I>, I: 'static,

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> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T, I>

where T: Config<I>, I: 'static,

fn on_initialize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number ) -> Weight

See [Hooks::on_initialize].

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

fn clone(&self) -> Pallet<T, I>

Returns a copy of the value.

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

Performs copy-assignment from source.