Enum pallet_society::Call

pub enum Call<T: Trait<I>, I: Instance = DefaultInstance> {
    bid(<<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance),
    unbid(u32),
    vouch(T::AccountId, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance),
    unvouch(u32),
    vote(<T::Lookup as StaticLookup>::Source, bool),
    defender_vote(bool),
    payout(),
    found(T::AccountId, u32, Vec<u8>),
    unfound(),
    judge_suspended_member(T::AccountId, bool),
    judge_suspended_candidate(T::AccountId, Judgement),
    set_max_members(u32),
    // some variants omitted
}

Dispatchable calls.

Each variant of this enum maps to a dispatchable function from the associated module.

Variants

bid(<<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance)

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

Payment: CandidateDeposit 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.

Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve)

• Storage Reads:
  • One storage read to check for suspended candidate. O(1)
  • One storage read to check for suspended member. O(1)
  • One storage read to retrieve all current bids. O(B)
  • One storage read to retrieve all current candidates. O(C)
  • One storage read to retrieve all members. O(M)
• Storage Writes:
  • One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)
  • Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)
• Notable Computation:
  • O(B + C + log M) search to check user is not already a part of society.
  • O(log B) search to insert the new bid sorted.
• External Module Operations:
  • One balance reserve operation. O(X)
  • Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.
• Events:
  • One event for new bid.
  • Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.

Total Complexity: O(M + B + C + logM + logB + X)

unbid(u32)

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.

Parameters:

• pos: Position in the Bids vector of the bid who wants to unbid.

Key: B (len of bids), X (balance unreserve)

• One storage read and write to retrieve and update the bids. O(B)
• Either one unreserve balance action O(X) or one vouching storage removal. O(1)
• One event.

Total Complexity: O(B + X)

vouch(T::AccountId, <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance, <<T as Trait<I>>::Currency as Currency<<T as Trait>::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.

Key: B (len of bids), C (len of candidates), M (len of members)

• Storage Reads:
  • One storage read to retrieve all members. O(M)
  • One storage read to check member is not already vouching. O(1)
  • One storage read to check for suspended candidate. O(1)
  • One storage read to check for suspended member. O(1)
  • One storage read to retrieve all current bids. O(B)
  • One storage read to retrieve all current candidates. O(C)
• Storage Writes:
  • One storage write to insert vouching status to the member. O(1)
  • One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization w/ read)
  • Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1)
• Notable Computation:
  • O(log M) search to check sender is a member.
  • O(B + C + log M) search to check user is not already a part of society.
  • O(log B) search to insert the new bid sorted.
• External Module Operations:
  • One balance reserve operation. O(X)
  • Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT.
• Events:
  • One event for vouch.
  • Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT.

Total Complexity: O(M + B + C + logM + logB + X)

unvouch(u32)

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.

Key: B (len of bids)

• One storage read O(1) to check the signer is a vouching member.
• One storage mutate to retrieve and update the bids. O(B)
• One vouching storage removal. O(1)
• One event.

Total Complexity: O(B)

vote(<T::Lookup as StaticLookup>::Source, 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).

Key: C (len of candidates), M (len of members)

• One storage read O(M) and O(log M) search to check user is a member.
• One account lookup.
• One storage read O(C) and O(C) search to check that user is a candidate.
• One storage write to add vote to votes. O(1)
• One event.

Total Complexity: O(M + logM + C)

defender_vote(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).

• Key: M (len of members)
• One storage read O(M) and O(log M) search to check user is a member.
• One storage write to add vote to votes. O(1)
• One event.

Total Complexity: O(M + logM)

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.

Key: M (len of members), P (number of payouts for a particular member)

• One storage read O(M) and O(log M) search to check signer is a member.
• One storage read O(P) to get all payouts for a member.
• One storage read O(1) to get the current block number.
• One currency transfer call. O(X)
• One storage write or removal to update the member's payouts. O(P)

Total Complexity: O(M + logM + P + X)

found(T::AccountId, u32, Vec<u8>)

Found the society.

This is done as a discrete action in order to allow for the module 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.
• rules - The rules of this society concerning membership.

• Two storage mutates to set Head and Founder. O(1)
• One storage write to add the first member to society. O(1)
• One event.

Total Complexity: O(1)

unfound()

Annul the founding of the society.

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.

• Two storage reads O(1).
• Four storage removals O(1).
• One event.

Total Complexity: O(1)

judge_suspended_member(T::AccountId, 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 from the SuspensionJudgementOrigin.

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.

Key: B (len of bids), M (len of members)

• One storage read to check who is a suspended member. O(1)
• Up to one storage write O(M) with O(log M) binary search to add a member back to society.
• Up to 3 storage removals O(1) to clean up a removed member.
• Up to one storage write O(B) with O(B) search to remove vouched bid from bids.
• Up to one additional event if unvouch takes place.
• One storage removal. O(1)
• One event for the judgement.

Total Complexity: O(M + logM + B)

judge_suspended_candidate(T::AccountId, Judgement)

Allow suspended judgement origin to make judgement on a suspended candidate.

If the judgement is Approve, we add them to society as a member with the appropriate payment for joining society.

If the judgement is Reject, we either slash the deposit of the bid, giving it back to the society treasury, or we ban the voucher from vouching again.

If the judgement is Rebid, we put the candidate back in the bid pool and let them go through the induction process again.

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

Parameters:

• who - The suspended candidate to be judged.
• judgement - Approve, Reject, or Rebid.

Key: B (len of bids), M (len of members), X (balance action)

• One storage read to check who is a suspended candidate.
• One storage removal of the suspended candidate.
• Approve Logic
  • One storage read to get the available pot to pay users with. O(1)
  • One storage write to update the available pot. O(1)
  • One storage read to get the current block number. O(1)
  • One storage read to get all members. O(M)
  • Up to one unreserve currency action.
  • Up to two new storage writes to payouts.
  • Up to one storage write with O(log M) binary search to add a member to society.
• Reject Logic
  • Up to one repatriate reserved currency action. O(X)
  • Up to one storage write to ban the vouching member from vouching again.
• Rebid Logic
  • Storage mutate with O(log B) binary search to place the user back into bids.
• Up to one additional event if unvouch takes place.
• One storage removal.
• One event for the judgement.

Total Complexity: O(M + logM + B + X)

set_max_members(u32)

Allows root origin to change the maximum number of members in society. Max membership count must be greater than 1.

The dispatch origin for this call must be from ROOT.

Parameters:

• max - The maximum number of members for the society.

• One storage write to update the max. O(1)
• One event.

Total Complexity: O(1)

Trait Implementations

impl<T: Trait<I>, I: Instance> 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: Trait<I>, I: Instance> Debug for Call<T, I>

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

Formats the value using the given formatter.

impl<T: Trait<I>, I: Instance> Decode for Call<T, I> where
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    <T::Lookup as StaticLookup>::Source: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode,
    T::AccountId: Decode, 

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

Attempt to deserialise the value from input.

impl<T: Trait<I>, I: Instance> Encode for Call<T, I> where
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <T::Lookup as StaticLookup>::Source: Encode,
    <T::Lookup as StaticLookup>::Source: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode, 

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

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

fn size_hint(&self) -> usize

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

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.

impl<T: Trait<I>, I: Instance> EncodeLike<Call<T, I>> for Call<T, I> where
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <<T as Trait<I>>::Currency as Currency<<T as Trait>::AccountId>>::Balance: Encode,
    <T::Lookup as StaticLookup>::Source: Encode,
    <T::Lookup as StaticLookup>::Source: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode,
    T::AccountId: Encode, 

impl<T: Trait<I>, I: Instance> Eq for Call<T, I>

impl<T: Trait<I>, I: Instance> 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.

impl<T: Trait<I>, I: Instance> GetDispatchInfo for Call<T, I>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Trait<I>, I: Instance> PartialEq<Call<T, I>> 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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Trait<I>, I: Instance> UnfilteredDispatchable for Call<T, I>

type Origin = T::Origin

The origin type of the runtime, (i.e. frame_system::Trait::Origin).

fn dispatch_bypass_filter(
    self,
    _origin: Self::Origin
) -> DispatchResultWithPostInfo

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