Struct pallet_liquidity_mining::GlobalFarmData

pub struct GlobalFarmData<T: Config<I>, I: 'static = ()> {
    pub id: GlobalFarmId,
    pub reward_currency: T::AssetId,
    pub incentivized_asset: T::AssetId,
    /* private fields */
}

This struct represents the state a of single liquidity mining program. YieldFarms are rewarded from GlobalFarm based on their stake in GlobalFarm. YieldFarm stake in GlobalFarm is derived from users stake in YieldFarm. Yield farm is considered live from global farm view if yield farm is active or stopped.

Fields

id: GlobalFarmId

reward_currency: T::AssetId

incentivized_asset: T::AssetId

Implementations

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

pub fn new(
    id: GlobalFarmId,
    updated_at: <T as Config>::BlockNumber,
    reward_currency: T::AssetId,
    yield_per_period: Perquintill,
    planned_yielding_periods: <T as Config>::BlockNumber,
    blocks_per_period: T::BlockNumber,
    owner: T::AccountId,
    incentivized_asset: T::AssetId,
    max_reward_per_period: Balance,
    min_deposit: Balance,
    price_adjustment: FixedU128
) -> Self

pub fn increase_yield_farm_counts(&mut self) -> Result<(), ArithmeticError>

This function updates yields_farm_count when new yield farm is added into the global farm. This function should be called only when new yield farm is created/added into the global farm.

pub fn decrease_live_yield_farm_count(&mut self) -> Result<(), Error<T, I>>

This function updates yield_farms_count when yield farm is terminated from global farm. This function should be called only when yield farm is removed from global farm.

pub fn decrease_total_yield_farm_count(&mut self) -> Result<(), Error<T, I>>

This function updates yield_farms_count when yield farm is removed from storage. This function should be called only if yield farm was removed from storage. !!! DON’T call this function if yield farm is in stopped or terminated.

pub fn has_live_farms(&self) -> bool

Function returns true if global farm has live yield farms.

pub fn can_be_removed(&self) -> bool

Function return true if global farm can be removed from storage.

pub fn is_full(&self) -> bool

This function returns true if farm has no capacity for next yield farm(yield farm can’t be added into global farm until some yield farm is removed from storage).

pub fn add_stake(&mut self, amount: Balance) -> Result<(), ArithmeticError>

Function adds amount to total_shares_z.

pub fn remove_stake(&mut self, amount: Balance) -> Result<(), Error<T, I>>

Function removes amount from total_shares_z.

Trait Implementations

impl<T: Clone + Config<I>, I: Clone + 'static> Clone for GlobalFarmData<T, I>where
    T::AccountId: Clone,
    T::AssetId: Clone,

fn clone(&self) -> GlobalFarmData<T, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, I> Debug for GlobalFarmData<T, I>where
    T: Debug + Config<I>,
    I: Debug + 'static,

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for GlobalFarmData<T, I>where
    T::AccountId: Decode,
    <T as Config>::BlockNumber: Decode,
    T::AssetId: Decode,
    BlockNumberFor<T>: Decode,

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

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<I>, I: 'static> Encode for GlobalFarmData<T, I>where
    T::AccountId: Encode,
    <T as Config>::BlockNumber: Encode,
    T::AssetId: Encode,
    BlockNumberFor<T>: Encode,

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

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, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    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<I>, I: 'static> MaxEncodedLen for GlobalFarmData<T, I>

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq<GlobalFarmData<T, I>> for GlobalFarmData<T, I>where
    T::AccountId: PartialEq,
    T::AssetId: PartialEq,

fn eq(&self, other: &GlobalFarmData<T, I>) -> 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> PriceAdjustment<GlobalFarmData<T, I>> for DefaultPriceAdjustment

type Error = DispatchError

type PriceAdjustment = FixedU128

fn get(
    global_farm: &GlobalFarmData<T, I>
) -> Result<Self::PriceAdjustment, Self::Error>

Returns value of PriceAdjustment for given GlobalFarm.

impl<T, I> TypeInfo for GlobalFarmData<T, I>where
    T::AccountId: TypeInfo + 'static,
    <T as Config>::BlockNumber: TypeInfo + 'static,
    T::AssetId: TypeInfo + 'static,
    BlockNumberFor<T>: TypeInfo + 'static,
    T: Config<I> + 'static,
    I: 'static,

type Identity = GlobalFarmData<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> EncodeLike<GlobalFarmData<T, I>> for GlobalFarmData<T, I>where
    T::AccountId: Encode,
    <T as Config>::BlockNumber: Encode,
    T::AssetId: Encode,
    BlockNumberFor<T>: Encode,

impl<T: Eq + Config<I>, I: Eq + 'static> Eq for GlobalFarmData<T, I>where
    T::AccountId: Eq,
    T::AssetId: Eq,

impl<T: Config<I>, I: 'static> StructuralEq for GlobalFarmData<T, I>

impl<T: Config<I>, I: 'static> StructuralPartialEq for GlobalFarmData<T, I>