Struct pallet_society::pallet::Pallet

pub struct Pallet<T, I = ()>(_);

The pallet implementing the on-chain logic.

Implementations

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

pub fn bid( origin: OriginFor<T>, value: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> DispatchResult

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 Pallet 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)

pub fn unbid(origin: OriginFor<T>, pos: u32) -> DispatchResult

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)

pub fn vouch( origin: OriginFor<T>, 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 ) -> DispatchResult

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 Pallet 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)

pub fn unvouch(origin: OriginFor<T>, pos: u32) -> DispatchResult

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)

pub fn vote( origin: OriginFor<T>, candidate: <<T as Config>::Lookup as StaticLookup>::Source, approve: bool ) -> DispatchResult

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)

pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResult

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)

pub fn payout(origin: OriginFor<T>) -> DispatchResult

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)

pub fn found( origin: OriginFor<T>, founder: <<T as Config>::Lookup as StaticLookup>::Source, max_members: u32, rules: Vec<u8> ) -> DispatchResult

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

pub fn unfound(origin: OriginFor<T>) -> DispatchResult

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)

pub fn judge_suspended_member( origin: OriginFor<T>, who: <<T as Config>::Lookup as StaticLookup>::Source, forgive: bool ) -> DispatchResult

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)

pub fn judge_suspended_candidate( origin: OriginFor<T>, who: <<T as Config>::Lookup as StaticLookup>::Source, judgement: Judgement ) -> DispatchResult

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)

pub fn set_max_members(origin: OriginFor<T>, max: u32) -> DispatchResult

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)

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

pub fn founder() -> Option<T::AccountId>

The first member.

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

pub fn rules() -> Option<T::Hash>

A hash of the rules of this society concerning membership. Can only be set once and only by the founder.

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

pub fn candidates( ) -> Vec<Bid<T::AccountId, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance>>

The current set of candidates; bidders that are attempting to become members.

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

pub fn suspended_candidate<KArg>( k: KArg ) -> Option<(<<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance, BidKind<T::AccountId, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance>)>where KArg: EncodeLike<T::AccountId>,

The set of suspended candidates.

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

pub fn pot( ) -> <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance

Amount of our account balance that is specifically for the next round’s bid(s).

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

pub fn head() -> Option<T::AccountId>

The most primary from the most recently approved members.

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

pub fn members() -> Vec<T::AccountId>

The current set of members, ordered.

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

pub fn suspended_member<KArg>(k: KArg) -> boolwhere KArg: EncodeLike<T::AccountId>,

The set of suspended members.

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

pub fn vouching<KArg>(k: KArg) -> Option<VouchingStatus>where KArg: EncodeLike<T::AccountId>,

Members currently vouching or banned from vouching again

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

pub fn defender() -> Option<T::AccountId>

The defending member currently being challenged.

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

pub fn max_members() -> u32

The max number of members for the society at one time.

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

pub fn remove_member(m: &T::AccountId) -> DispatchResult

Remove a member from the members list, except the Head.

NOTE: This does not correctly clean up a member from storage. It simply removes them from the Members storage item.

pub fn account_id() -> T::AccountId

The account ID of the treasury pot.

This actually does computation. If you need to keep using it, then make sure you cache the value and only call this once.

pub fn payouts() -> T::AccountId

The account ID of the payouts pot. This is where payouts are made from.

This actually does computation. If you need to keep using it, then make sure you cache the value and only call this once.

pub fn take_selected( members_len: usize, pot: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance ) -> Vec<Bid<T::AccountId, <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::Balance>>

Get a selection of bidding accounts such that the total bids is no greater than Pot and the number of bids would not surpass MaxMembers if all were accepted.

May be empty.

Trait Implementations

impl<T: Config<I>, I: 'static> Callable<T> for Pallet<T, I>

type RuntimeCall = Call<T, I>

impl<T, I> Clone for Pallet<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, I> Debug for Pallet<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> GetStorageVersion for Pallet<T, I>

fn current_storage_version() -> StorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config<I>, I: 'static> Hooks<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_initialize(n: T::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

impl<T: Config<I>, I: 'static> IntegrityTest for Pallet<T, I>

fn integrity_test()

Run integrity test.

impl<T: Config<I>, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>

fn offchain_worker(n: <T as Config>::BlockNumber)

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

impl<T: Config<I>, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Config<I>, I: 'static> OnGenesis for Pallet<T, I>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config<I>, I: 'static> OnIdle<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config<I>, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Pallet<T, I>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: Config<I>, I: 'static> OnUnbalanced<<<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::NegativeImbalance> for Pallet<T, I>

fn on_nonzero_unbalanced( amount: <<T as Config<I>>::Currency as Currency<<T as Config>::AccountId>>::NegativeImbalance )

Actually handle a non-zero imbalance. You probably want to implement this rather than on_unbalanced.

fn on_unbalanceds<B>(amounts: impl Iterator<Item = Imbalance>)where Imbalance: Imbalance<B>,

Handler for some imbalances. The different imbalances might have different origins or meanings, dependent on the context. Will default to simply calling on_unbalanced for all of them. Infallible.

fn on_unbalanced(amount: Imbalance)

Handler for some imbalance. Infallible.

impl<T: Config<I>, I: 'static> PalletInfoAccess for Pallet<T, I>

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 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: Config<I>, I: 'static> PalletsInfoAccess for Pallet<T, I>

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<Pallet<T, I>> for Pallet<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: Config<I>, I: 'static> StorageInfoTrait for Pallet<T, I>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config<I>, I: 'static> WhitelistedStorageKeys for Pallet<T, I>

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>