Struct pallet_plasm_rewards::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn for_dapps_era_reward<K: EncodeLike<EraIndex>>(
    key: K
) -> Option<BalanceOf<T>>

This is the compensation paid for the dapps operator of the Plasm Network. This is stored on a per-era basis.

pub fn for_security_era_reward<K: EncodeLike<EraIndex>>(
    key: K
) -> Option<BalanceOf<T>>

This is the compensation paid for the security of the Plasm Network. This is stored on a per-era basis.

pub fn history_depth() -> u32

Number of era to keep in history.

Information is kept for eras in [current_era - history_depth; current_era]

Must be more than the number of era delayed by session otherwise. i.e. active era must always be in history. i.e. active_era > current_era - history_depth must be guaranteed.

24 * 28 = 672 eras is roughly 28 days on current Plasm Network. That seems like a reasonable length of time for users to claim a payout

pub fn current_era() -> Option<EraIndex>

The current era index.

This is the latest planned era, depending on how session module queues the validator set, it might be active or not.

pub fn active_era() -> Option<ActiveEraInfo<MomentOf<T>>>

The active era information, it holds index and start.

The active era is the era currently rewarded. Validator set of this era must be equal to SessionInterface::validators.

pub fn eras_start_session_index<K: EncodeLike<EraIndex>>(
    key: K
) -> Option<SessionIndex>

The session index at which the era start for the last HISTORY_DEPTH eras

pub fn force_era() -> Forcing

True if the next session change will be a new era regardless of index.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> EraFinder<u32, u32, <<T as Trait>::Time as Time>::Moment> for Module<T>

In this implementation using validator and dapps rewards module.

fn current() -> Option<EraIndex>

The current era index.

fn active() -> Option<ActiveEraInfo<MomentOf<T>>>

The active era information, it holds index and start.

fn start_session_index(era: &EraIndex) -> Option<SessionIndex>

The session index at which the era start for the last HISTORY_DEPTH eras

impl<T: Trait> ForDappsEraRewardFinder<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>

Get the dapps rewards for dapps staking module.

fn get(era: &EraIndex) -> Option<BalanceOf<T>>

impl<T: Trait> ForSecurityEraRewardFinder<<<T as Trait>::Currency as Currency<<T as Trait>::AccountId>>::Balance> for Module<T>

Get the security rewards for validator module.

fn get(era: &EraIndex) -> Option<BalanceOf<T>>

impl<T: Trait> HistoryDepthFinder for Module<T>

Get the history depth

fn get() -> u32

impl<T: Trait> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

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

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_block_number_not_used: T::BlockNumber)

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

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

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

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

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

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

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> SessionManager<<T as Trait>::AccountId> for Module<T>

In this implementation new_session(session) must be called before end_session(session-1) i.e. the new session must be planned before the ending of the previous session.

Once the first new_session is planned, all session must start and then end in order, though some session can lag in between the newest session planned and the latest session started.

fn new_session(new_index: SessionIndex) -> Option<Vec<T::AccountId>>

Plan a new session, and optionally provide the new validator set.

fn start_session(start_index: SessionIndex)

Start the session.

fn end_session(end_index: SessionIndex)

End the session.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>