Struct gekko::runtime::kusama::extrinsics::council::Close

pub struct Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,  {
    pub proposal_hash: A,
    pub index: B,
    pub proposal_weight_bound: C,
    pub length_bound: D,
}

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

Documentation (provided by the runtime metadata)

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

Type Disclaimer

This library makes no assumptions about parameter types and must be specified manually as generic types. Each field contains a type description which can serve as a hint on what type is being expected, as provided by the runtime meatadata. See the common module for common types which can be used.

Fields

proposal_hash: A

Type description: T::Hash

index: B

Type description: Compact<ProposalIndex>

proposal_weight_bound: C

Type description: Compact<Weight>

length_bound: D

Type description: Compact<u32>

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone> Clone for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

fn clone(&self) -> Close<A, B, C, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug, D: Debug> Debug for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

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

Formats the value using the given formatter.

impl<A, B, C, D> Decode for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

fn decode<SI: Input>(input: &mut SI) -> Result<Self, Error>

Attempt to deserialise the value from input.

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<A, B, C, D> Encode for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

fn using_encoded<SR, SF: FnOnce(&[u8]) -> SR>(&self, f: SF) -> SR

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

fn size_hint(&self) -> usize

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

fn encode_to<T>(&self, dest: &mut T) where
    T: Output + ?Sized, 

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

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

Convert self to an owned vector.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq> PartialEq<Close<A, B, C, D>> for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

fn eq(&self, other: &Close<A, B, C, D>) -> bool

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

fn ne(&self, other: &Close<A, B, C, D>) -> bool

This method tests for !=.

impl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

impl<A, B, C, D> StructuralEq for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode, 

impl<A, B, C, D> StructuralPartialEq for Close<A, B, C, D> where
    A: Encode + Decode,
    B: Encode + Decode,
    C: Encode + Decode,
    D: Encode + Decode,