Type Alias AllianceMotion

pub type AllianceMotion = Pallet<Runtime, Instance1>;

Aliased Type

struct AllianceMotion(/* 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)

pub fn kill( origin: <T as Config>::RuntimeOrigin, proposal_hash: <T as Config>::Hash, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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.

pub fn release_proposal_cost( origin: <T as Config>::RuntimeOrigin, proposal_hash: <T as Config>::Hash, ) -> Result<(), DispatchError>

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.

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

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

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

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

type RuntimeCall = Call<T, I>

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

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

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

fn dispatch_view_function<O>( id: &ViewFunctionId, input: &mut &[u8], output: &mut O, ) -> Result<(), ViewFunctionDispatchError>

where O: Output,

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 try_state( _n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, ) -> Result<(), DispatchError>

Execute the sanity checks of this pallet, per block.

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 pre_upgrade() -> Result<Vec<u8>, DispatchError>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade(_state: Vec<u8>) -> Result<(), DispatchError>

Execute some post-checks after a runtime upgrade.

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

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

fn integrity_test()

See Hooks::integrity_test.

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

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

fn on_genesis()

Something that should happen at genesis.

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

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

fn on_runtime_upgrade() -> Weight

See Hooks::on_runtime_upgrade.

fn pre_upgrade() -> Result<Vec<u8>, DispatchError>

See Hooks::pre_upgrade.

fn post_upgrade(state: Vec<u8>) -> Result<(), DispatchError>

See Hooks::post_upgrade.

fn try_on_runtime_upgrade(checks: bool) -> Result<Weight, DispatchError>

The expected and default behavior of this method is to handle executing pre_upgrade -> on_runtime_upgrade -> post_upgrade hooks for a migration.

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

fn eq(&self, other: &Pallet<T, I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

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

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

fn storage_info() -> Vec<StorageInfo>

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

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

fn try_decode_entire_state() -> Result<usize, Vec<TryDecodeEntireStorageError>>

Decode the entire data under the given storage, returning Ok(bytes_decoded) if success.

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

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

fn try_state( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, _s: Select, ) -> Result<(), DispatchError>

Execute the state checks.

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

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

fn prefix() -> [u8; 16]

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