Enum Call

pub enum Call<T: Config> {
    create_pool {
        staked_asset_id: Box<T::AssetId>,
        reward_asset_id: Box<T::AssetId>,
        reward_rate_per_block: T::Balance,
        expiry: DispatchTime<BlockNumberFor<T>>,
        admin: Option<T::AccountId>,
    },
    stake {
        pool_id: PoolId,
        amount: T::Balance,
    },
    unstake {
        pool_id: PoolId,
        amount: T::Balance,
        staker: Option<T::AccountId>,
    },
    harvest_rewards {
        pool_id: PoolId,
        staker: Option<T::AccountId>,
    },
    set_pool_reward_rate_per_block {
        pool_id: PoolId,
        new_reward_rate_per_block: T::Balance,
    },
    set_pool_admin {
        pool_id: PoolId,
        new_admin: T::AccountId,
    },
    set_pool_expiry_block {
        pool_id: PoolId,
        new_expiry: DispatchTime<BlockNumberFor<T>>,
    },
    deposit_reward_tokens {
        pool_id: PoolId,
        amount: T::Balance,
    },
    cleanup_pool {
        pool_id: PoolId,
    },
    // some variants omitted
}

Pallet’s callable functions.

Variants

create_pool

Create a new reward pool.

Parameters:

• origin: must be Config::CreatePoolOrigin;
• staked_asset_id: the asset to be staked in the pool;
• reward_asset_id: the asset to be distributed as rewards;
• reward_rate_per_block: the amount of reward tokens distributed per block;
• expiry: the block number at which the pool will cease to accumulate rewards. The DispatchTime::After variant evaluated at the execution time.
• admin: the account allowed to extend the pool expiration, increase the rewards rate and receive the unutilized reward tokens back after the pool completion. If None, the caller is set as an admin.

Fields

staked_asset_id: Box<T::AssetId>

reward_asset_id: Box<T::AssetId>

reward_rate_per_block: T::Balance

expiry: DispatchTime<BlockNumberFor<T>>

admin: Option<T::AccountId>

stake

Stake additional tokens in a pool.

A freeze is placed on the staked tokens.

Fields

pool_id: PoolId

amount: T::Balance

unstake

Unstake tokens from a pool.

Removes the freeze on the staked tokens.

Parameters:

• origin: must be the staker if the pool is still active. Otherwise, any account.
• pool_id: the pool to unstake from.
• amount: the amount of tokens to unstake.
• staker: the account to unstake from. If None, the caller is used.

Fields

pool_id: PoolId

amount: T::Balance

staker: Option<T::AccountId>

harvest_rewards

Harvest unclaimed pool rewards.

Parameters:

• origin: must be the staker if the pool is still active. Otherwise, any account.
• pool_id: the pool to harvest from.
• staker: the account for which to harvest rewards. If None, the caller is used.

Fields

pool_id: PoolId

staker: Option<T::AccountId>

set_pool_reward_rate_per_block

Modify a pool reward rate.

Currently the reward rate can only be increased.

Only the pool admin may perform this operation.

Fields

pool_id: PoolId

new_reward_rate_per_block: T::Balance

set_pool_admin

Modify a pool admin.

Only the pool admin may perform this operation.

Fields

pool_id: PoolId

new_admin: T::AccountId

set_pool_expiry_block

Set when the pool should expire.

Currently the expiry block can only be extended.

Only the pool admin may perform this operation.

Fields

pool_id: PoolId

new_expiry: DispatchTime<BlockNumberFor<T>>

deposit_reward_tokens

Convenience method to deposit reward tokens into a pool.

This method is not strictly necessary (tokens could be transferred directly to the pool pot address), but is provided for convenience so manual derivation of the account id is not required.

Fields

pool_id: PoolId

amount: T::Balance

cleanup_pool

Cleanup a pool.

Origin must be the pool admin.

Cleanup storage, release any associated storage cost and return the remaining reward tokens to the admin.

Fields

pool_id: PoolId

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_create_pool( staked_asset_id: Box<T::AssetId>, reward_asset_id: Box<T::AssetId>, reward_rate_per_block: T::Balance, expiry: DispatchTime<BlockNumberFor<T>>, admin: Option<T::AccountId>, ) -> Self

Create a call with the variant create_pool.

pub fn new_call_variant_stake(pool_id: PoolId, amount: T::Balance) -> Self

Create a call with the variant stake.

pub fn new_call_variant_unstake( pool_id: PoolId, amount: T::Balance, staker: Option<T::AccountId>, ) -> Self

Create a call with the variant unstake.

pub fn new_call_variant_harvest_rewards( pool_id: PoolId, staker: Option<T::AccountId>, ) -> Self

Create a call with the variant harvest_rewards.

pub fn new_call_variant_set_pool_reward_rate_per_block( pool_id: PoolId, new_reward_rate_per_block: T::Balance, ) -> Self

Create a call with the variant set_pool_reward_rate_per_block.

pub fn new_call_variant_set_pool_admin( pool_id: PoolId, new_admin: T::AccountId, ) -> Self

Create a call with the variant set_pool_admin.

pub fn new_call_variant_set_pool_expiry_block( pool_id: PoolId, new_expiry: DispatchTime<BlockNumberFor<T>>, ) -> Self

Create a call with the variant set_pool_expiry_block.

pub fn new_call_variant_deposit_reward_tokens( pool_id: PoolId, amount: T::Balance, ) -> Self

Create a call with the variant deposit_reward_tokens.

pub fn new_call_variant_cleanup_pool(pool_id: PoolId) -> Self

Create a call with the variant cleanup_pool.

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

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, Box<T::AssetId>: TypeInfo + 'static, T::Balance: TypeInfo + 'static, DispatchTime<BlockNumberFor<T>>: TypeInfo + 'static, Option<T::AccountId>: TypeInfo + 'static, 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> DecodeWithMemTracking for Call<T>

where Box<T::AssetId>: DecodeWithMemTracking, T::Balance: DecodeWithMemTracking, DispatchTime<BlockNumberFor<T>>: DecodeWithMemTracking, Option<T::AccountId>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking,

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

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