Enum pallet_society::pallet::Call

pub enum Call<T: Config<I>, I: 'static = ()> {
    bid {
        value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    unbid {},
    vouch {
        who: <<T as Config>::Lookup as StaticLookup>::Source,
        value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        tip: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    unvouch {},
    vote {
        candidate: <<T as Config>::Lookup as StaticLookup>::Source,
        approve: bool,
    },
    defender_vote {
        approve: bool,
    },
    payout {},
    waive_repay {
        amount: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    found_society {
        founder: <<T as Config>::Lookup as StaticLookup>::Source,
        max_members: u32,
        max_intake: u32,
        max_strikes: u32,
        candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        rules: Vec<u8>,
    },
    dissolve {},
    judge_suspended_member {
        who: <<T as Config>::Lookup as StaticLookup>::Source,
        forgive: bool,
    },
    set_parameters {
        max_members: u32,
        max_intake: u32,
        max_strikes: u32,
        candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    punish_skeptic {},
    claim_membership {},
    bestow_membership {
        candidate: T::AccountId,
    },
    kick_candidate {
        candidate: T::AccountId,
    },
    resign_candidacy {},
    drop_candidate {
        candidate: T::AccountId,
    },
    cleanup_candidacy {
        candidate: T::AccountId,
        max: u32,
    },
    cleanup_challenge {
        challenge_round: RoundIndex,
        max: u32,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

bid

Fields

value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

A user outside of the society can make a bid for entry.

Payment: The group’s Candidate Deposit will be reserved for making a bid. It is returned when the bid becomes a member, or if the bid calls unbid.

The dispatch origin for this call must be Signed.

Parameters:

• value: A one time payment the bid would like to receive when joining the society.

unbid

A bidder can remove their bid for entry into society. By doing so, they will have their candidate deposit returned or they will unvouch their voucher.

Payment: The bid deposit is unreserved if the user made a bid.

The dispatch origin for this call must be Signed and a bidder.

vouch

Fields

who: <<T as Config>::Lookup as StaticLookup>::Source

value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

tip: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

As a member, vouch for someone to join society by placing a bid on their behalf.

There is no deposit required to vouch for a new bid, but a member can only vouch for one bid at a time. If the bid becomes a suspended candidate and ultimately rejected by the suspension judgement origin, the member will be banned from vouching again.

As a vouching member, you can claim a tip if the candidate is accepted. This tip will be paid as a portion of the reward the member will receive for joining the society.

The dispatch origin for this call must be Signed and a member.

Parameters:

• who: The user who you would like to vouch for.
• value: The total reward to be paid between you and the candidate if they become a member in the society.
• tip: Your cut of the total value payout when the candidate is inducted into the society. Tips larger than value will be saturated upon payout.

unvouch

As a vouching member, unvouch a bid. This only works while vouched user is only a bidder (and not a candidate).

The dispatch origin for this call must be Signed and a vouching member.

Parameters:

• pos: Position in the Bids vector of the bid who should be unvouched.

vote

Fields

candidate: <<T as Config>::Lookup as StaticLookup>::Source

approve: bool

As a member, vote on a candidate.

The dispatch origin for this call must be Signed and a member.

Parameters:

• candidate: The candidate that the member would like to bid on.
• approve: A boolean which says if the candidate should be approved (true) or rejected (false).

defender_vote

Fields

approve: bool

As a member, vote on the defender.

The dispatch origin for this call must be Signed and a member.

Parameters:

• approve: A boolean which says if the candidate should be approved (true) or rejected (false).

payout

Transfer the first matured payout for the sender and remove it from the records.

NOTE: This extrinsic needs to be called multiple times to claim multiple matured payouts.

Payment: The member will receive a payment equal to their first matured payout to their free balance.

The dispatch origin for this call must be Signed and a member with payouts remaining.

waive_repay

Fields

amount: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

Repay the payment previously given to the member with the signed origin, remove any pending payments, and elevate them from rank 0 to rank 1.

found_society

Fields

founder: <<T as Config>::Lookup as StaticLookup>::Source

max_members: u32

max_intake: u32

max_strikes: u32

candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

rules: Vec<u8>

Found the society.

This is done as a discrete action in order to allow for the pallet to be included into a running chain and can only be done once.

The dispatch origin for this call must be from the FounderSetOrigin.

Parameters:

• founder - The first member and head of the newly founded society.
• max_members - The initial max number of members for the society.
• max_intake - The maximum number of candidates per intake period.
• max_strikes: The maximum number of strikes a member may get before they become suspended and may only be reinstated by the founder.
• candidate_deposit: The deposit required to make a bid for membership of the group.
• rules - The rules of this society concerning membership.

Complexity: O(1)

dissolve

Dissolve the society and remove all members.

The dispatch origin for this call must be Signed, and the signing account must be both the Founder and the Head. This implies that it may only be done when there is one member.

judge_suspended_member

Fields

who: <<T as Config>::Lookup as StaticLookup>::Source

forgive: bool

Allow suspension judgement origin to make judgement on a suspended member.

If a suspended member is forgiven, we simply add them back as a member, not affecting any of the existing storage items for that member.

If a suspended member is rejected, remove all associated storage items, including their payouts, and remove any vouched bids they currently have.

The dispatch origin for this call must be Signed from the Founder.

Parameters:

• who - The suspended member to be judged.
• forgive - A boolean representing whether the suspension judgement origin forgives (true) or rejects (false) a suspended member.

set_parameters

Fields

max_members: u32

max_intake: u32

max_strikes: u32

candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

Change the maximum number of members in society and the maximum number of new candidates in a single intake period.

The dispatch origin for this call must be Signed by the Founder.

Parameters:

• max_members - The maximum number of members for the society. This must be no less than the current number of members.
• max_intake - The maximum number of candidates per intake period.
• max_strikes: The maximum number of strikes a member may get before they become suspended and may only be reinstated by the founder.
• candidate_deposit: The deposit required to make a bid for membership of the group.

punish_skeptic

Punish the skeptic with a strike if they did not vote on a candidate. Callable by the candidate.

claim_membership

Transform an approved candidate into a member. Callable only by the the candidate, and only after the period for voting has ended.

bestow_membership

Fields

candidate: T::AccountId

Transform an approved candidate into a member. Callable only by the Signed origin of the Founder, only after the period for voting has ended and only when the candidate is not clearly rejected.

kick_candidate

Fields

candidate: T::AccountId

Remove the candidate’s application from the society. Callable only by the Signed origin of the Founder, only after the period for voting has ended, and only when they do not have a clear approval.

Any bid deposit is lost and voucher is banned.

resign_candidacy

Remove the candidate’s application from the society. Callable only by the candidate.

Any bid deposit is lost and voucher is banned.

drop_candidate

Fields

candidate: T::AccountId

Remove a candidate’s failed application from the society. Callable by any signed origin but only at the end of the subsequent round and only for a candidate with more rejections than approvals.

The bid deposit is lost and the voucher is banned.

cleanup_candidacy

Fields

candidate: T::AccountId

max: u32

Remove up to max stale votes for the given candidate.

May be called by any Signed origin, but only after the candidate’s candidacy is ended.

cleanup_challenge

Fields

challenge_round: RoundIndex

max: u32

Remove up to max stale votes for the defender in the given challenge_round.

May be called by any Signed origin, but only after the challenge round is ended.

Implementations

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

pub fn new_call_variant_bid( value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> Self

Create a call with the variant bid.

pub fn new_call_variant_unbid() -> Self

Create a call with the variant unbid.

pub fn new_call_variant_vouch( who: <<T as Config>::Lookup as StaticLookup>::Source, value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance, tip: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> Self

Create a call with the variant vouch.

pub fn new_call_variant_unvouch() -> Self

Create a call with the variant unvouch.

pub fn new_call_variant_vote( candidate: <<T as Config>::Lookup as StaticLookup>::Source, approve: bool ) -> Self

Create a call with the variant vote.

pub fn new_call_variant_defender_vote(approve: bool) -> Self

Create a call with the variant defender_vote.

pub fn new_call_variant_payout() -> Self

Create a call with the variant payout.

pub fn new_call_variant_waive_repay( amount: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> Self

Create a call with the variant waive_repay.

pub fn new_call_variant_found_society( founder: <<T as Config>::Lookup as StaticLookup>::Source, max_members: u32, max_intake: u32, max_strikes: u32, candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance, rules: Vec<u8> ) -> Self

Create a call with the variant found_society.

pub fn new_call_variant_dissolve() -> Self

Create a call with the variant dissolve.

pub fn new_call_variant_judge_suspended_member( who: <<T as Config>::Lookup as StaticLookup>::Source, forgive: bool ) -> Self

Create a call with the variant judge_suspended_member.

pub fn new_call_variant_set_parameters( max_members: u32, max_intake: u32, max_strikes: u32, candidate_deposit: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> Self

Create a call with the variant set_parameters.

pub fn new_call_variant_punish_skeptic() -> Self

Create a call with the variant punish_skeptic.

pub fn new_call_variant_claim_membership() -> Self

Create a call with the variant claim_membership.

pub fn new_call_variant_bestow_membership(candidate: T::AccountId) -> Self

Create a call with the variant bestow_membership.

pub fn new_call_variant_kick_candidate(candidate: T::AccountId) -> Self

Create a call with the variant kick_candidate.

pub fn new_call_variant_resign_candidacy() -> Self

Create a call with the variant resign_candidacy.

pub fn new_call_variant_drop_candidate(candidate: T::AccountId) -> Self

Create a call with the variant drop_candidate.

pub fn new_call_variant_cleanup_candidacy( candidate: T::AccountId, max: u32 ) -> Self

Create a call with the variant cleanup_candidacy.

pub fn new_call_variant_cleanup_challenge( challenge_round: RoundIndex, max: u32 ) -> Self

Create a call with the variant cleanup_challenge.

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, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static, <<T as Config>::Lookup as StaticLookup>::Source: TypeInfo + 'static, T::AccountId: 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>