Enum pallet_dapp_staking::pallet::Call

pub enum Call<T: Config> {
    unbond_and_unstake {
        contract_id: T::SmartContract,
        value: Balance,
    },
    withdraw_unbonded {},
    maintenance_mode {
        enabled: bool,
    },
    register {
        owner: T::AccountId,
        smart_contract: T::SmartContract,
    },
    set_dapp_reward_beneficiary {
        smart_contract: T::SmartContract,
        beneficiary: Option<T::AccountId>,
    },
    set_dapp_owner {
        smart_contract: T::SmartContract,
        new_owner: T::AccountId,
    },
    unregister {
        smart_contract: T::SmartContract,
    },
    lock {
        amount: Balance,
    },
    unlock {
        amount: Balance,
    },
    claim_unlocked {},
    relock_unlocking {},
    stake {
        smart_contract: T::SmartContract,
        amount: Balance,
    },
    unstake {
        smart_contract: T::SmartContract,
        amount: Balance,
    },
    claim_staker_rewards {},
    claim_bonus_reward {
        smart_contract: T::SmartContract,
    },
    claim_dapp_reward {
        smart_contract: T::SmartContract,
        era: EraNumber,
    },
    unstake_from_unregistered {
        smart_contract: T::SmartContract,
    },
    cleanup_expired_entries {},
    force {
        forcing_type: ForcingType,
    },
    claim_staker_rewards_for {
        account: T::AccountId,
    },
    claim_bonus_reward_for {
        account: T::AccountId,
        smart_contract: T::SmartContract,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

unbond_and_unstake

Fields

contract_id: T::SmartContract

value: Balance

Wrapper around legacy-like unbond_and_unstake.

Used to support legacy Ledger users so they can start the unlocking process for their funds.

withdraw_unbonded

Wrapper around legacy-like withdraw_unbonded.

Used to support legacy Ledger users so they can reclaim unlocked chunks back into their transferable free balance.

maintenance_mode

Fields

enabled: bool

Used to enable or disable maintenance mode. Can only be called by manager origin.

register

Fields

owner: T::AccountId

smart_contract: T::SmartContract

Used to register a new contract for dApp staking.

If successful, smart contract will be assigned a simple, unique numerical identifier. Owner is set to be initial beneficiary & manager of the dApp.

set_dapp_reward_beneficiary

Fields

smart_contract: T::SmartContract

beneficiary: Option<T::AccountId>

Used to modify the reward beneficiary account for a dApp.

Caller has to be dApp owner. If set to None, rewards will be deposited to the dApp owner. After this call, all existing & future rewards will be paid out to the beneficiary.

set_dapp_owner

Fields

smart_contract: T::SmartContract

new_owner: T::AccountId

Used to change dApp owner.

Can be called by dApp owner or dApp staking manager origin. This is useful in two cases:

1. when the dApp owner account is compromised, manager can change the owner to a new account
2. if project wants to transfer ownership to a new account (DAO, multisig, etc.).

unregister

Fields

smart_contract: T::SmartContract

Unregister dApp from dApp staking protocol, making it ineligible for future rewards. This doesn’t remove the dApp completely from the system just yet, but it can no longer be used for staking.

Can be called by dApp staking manager origin.

lock

Fields

amount: Balance

Locks additional funds into dApp staking.

In case caller account doesn’t have sufficient balance to cover the specified amount, everything is locked. After adjustment, lock amount must be greater than zero and in total must be equal or greater than the minimum locked amount.

Locked amount can immediately be used for staking.

unlock

Fields

amount: Balance

Attempts to start the unlocking process for the specified amount.

Only the amount that isn’t actively used for staking can be unlocked. If the amount is greater than the available amount for unlocking, everything is unlocked. If the remaining locked amount would take the account below the minimum locked amount, everything is unlocked.

claim_unlocked

Claims all of fully unlocked chunks, removing the lock from them.

relock_unlocking

stake

Fields

smart_contract: T::SmartContract

amount: Balance

Stake the specified amount on a smart contract. The precise amount specified must be available for staking. The total amount staked on a dApp must be greater than the minimum required value.

Depending on the period type, appropriate stake amount will be updated. During Voting subperiod, voting stake amount is updated, and same for Build&Earn subperiod.

Staked amount is only eligible for rewards from the next era onwards.

unstake

Fields

smart_contract: T::SmartContract

amount: Balance

Unstake the specified amount from a smart contract. The amount specified must not exceed what’s staked, otherwise the call will fail.

If unstaking the specified amount would take staker below the minimum stake threshold, everything is unstaked.

Depending on the period type, appropriate stake amount will be updated. In case amount is unstaked during Voting subperiod, the voting amount is reduced. In case amount is unstaked during Build&Earn subperiod, first the build_and_earn is reduced, and any spillover is subtracted from the voting amount.

claim_staker_rewards

Claims some staker rewards, if user has any. In the case of a successful call, at least one era will be claimed, with the possibility of multiple claims happening.

claim_bonus_reward

Fields

smart_contract: T::SmartContract

Used to claim bonus reward for a smart contract, if eligible.

claim_dapp_reward

Fields

smart_contract: T::SmartContract

era: EraNumber

Used to claim dApp reward for the specified era.

unstake_from_unregistered

Fields

smart_contract: T::SmartContract

Used to unstake funds from a contract that was unregistered after an account staked on it. This is required if staker wants to re-stake these funds on another active contract during the ongoing period.

cleanup_expired_entries

Cleanup expired stake entries for the contract.

Entry is considered to be expired if:

1. It’s from a past period & the account wasn’t a loyal staker, meaning there’s no claimable bonus reward.
2. It’s from a period older than the oldest claimable period, regardless whether the account was loyal or not.

force

Fields

forcing_type: ForcingType

Used to force a change of era or subperiod. The effect isn’t immediate but will happen on the next block.

Used for testing purposes, when we want to force an era change, or a subperiod change. Not intended to be used in production, except in case of unforeseen circumstances.

Can only be called by the root origin.

claim_staker_rewards_for

Fields

account: T::AccountId

Claims some staker rewards for the specified account, if they have any. In the case of a successful call, at least one era will be claimed, with the possibility of multiple claims happening.

claim_bonus_reward_for

Fields

account: T::AccountId

smart_contract: T::SmartContract

Used to claim bonus reward for a smart contract on behalf of the specified account, if eligible.

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_unbond_and_unstake( contract_id: T::SmartContract, value: Balance ) -> Self

Create a call with the variant unbond_and_unstake.

pub fn new_call_variant_withdraw_unbonded() -> Self

Create a call with the variant withdraw_unbonded.

pub fn new_call_variant_maintenance_mode(enabled: bool) -> Self

Create a call with the variant maintenance_mode.

pub fn new_call_variant_register( owner: T::AccountId, smart_contract: T::SmartContract ) -> Self

Create a call with the variant register.

pub fn new_call_variant_set_dapp_reward_beneficiary( smart_contract: T::SmartContract, beneficiary: Option<T::AccountId> ) -> Self

Create a call with the variant set_dapp_reward_beneficiary.

pub fn new_call_variant_set_dapp_owner( smart_contract: T::SmartContract, new_owner: T::AccountId ) -> Self

Create a call with the variant set_dapp_owner.

pub fn new_call_variant_unregister(smart_contract: T::SmartContract) -> Self

Create a call with the variant unregister.

pub fn new_call_variant_lock(amount: Balance) -> Self

Create a call with the variant lock.

pub fn new_call_variant_unlock(amount: Balance) -> Self

Create a call with the variant unlock.

pub fn new_call_variant_claim_unlocked() -> Self

Create a call with the variant claim_unlocked.

pub fn new_call_variant_relock_unlocking() -> Self

Create a call with the variant relock_unlocking.

pub fn new_call_variant_stake( smart_contract: T::SmartContract, amount: Balance ) -> Self

Create a call with the variant stake.

pub fn new_call_variant_unstake( smart_contract: T::SmartContract, amount: Balance ) -> Self

Create a call with the variant unstake.

pub fn new_call_variant_claim_staker_rewards() -> Self

Create a call with the variant claim_staker_rewards.

pub fn new_call_variant_claim_bonus_reward( smart_contract: T::SmartContract ) -> Self

Create a call with the variant claim_bonus_reward.

pub fn new_call_variant_claim_dapp_reward( smart_contract: T::SmartContract, era: EraNumber ) -> Self

Create a call with the variant claim_dapp_reward.

pub fn new_call_variant_unstake_from_unregistered( smart_contract: T::SmartContract ) -> Self

Create a call with the variant unstake_from_unregistered.

pub fn new_call_variant_cleanup_expired_entries() -> Self

Create a call with the variant cleanup_expired_entries.

pub fn new_call_variant_force(forcing_type: ForcingType) -> Self

Create a call with the variant force.

pub fn new_call_variant_claim_staker_rewards_for(account: T::AccountId) -> Self

Create a call with the variant claim_staker_rewards_for.

pub fn new_call_variant_claim_bonus_reward_for( account: T::AccountId, smart_contract: T::SmartContract ) -> Self

Create a call with the variant claim_bonus_reward_for.

Trait Implementations

impl<T: Config> CheckIfFeeless for Call<T>

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> Clone for Call<T>

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> Debug for Call<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<T>

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> Encode for Call<T>

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> GetCallIndex for Call<T>

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> GetCallName for Call<T>

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> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<T>

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> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, T::SmartContract: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

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> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>