Struct XpState

pub struct XpState<T: Config<I>, I: 'static> {
    pub liquid: T::Xp,
    pub reserved: T::Xp,
    pub locked: T::Xp,
    pub multiplier: T::Pulse,
    pub eligibility: XpEligibility<T, I>,
}

Snapshot of an identity’s XP-related state.

Combines balance information with XP activation and multiplier data. Designed for RPC responses and UI consumption, where both current value and progression state need to be displayed together.

Fields

liquid: T::Xp

Freely usable balance.

reserved: T::Xp

Balance reserved for protocol-level usage.

locked: T::Xp

Balance locked by constraints (e.g. vesting, staking).

multiplier: T::Pulse

Current XP multiplier.

Returns 1 while XP is not yet active. Once eligible, this reflects the effective multiplier applied to XP gains.

Note: The multiplier is applied only if the next earn_xp call occurs in a new block (last_earn < current block). If multiple calls are made within the same block, only the first applies the multiplier; subsequent calls are unscaled.

eligibility: XpEligibility<T, I>

XP activation state.

Indicates whether XP is currently being earned, or how much progress remains before it starts counting.

Trait Implementations

impl<T: Clone + Config<I>, I: Clone + 'static> Clone for XpState<T, I>

where T::Xp: Clone, T::Pulse: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T::Xp: Decode, T::Pulse: Decode, XpEligibility<T, I>: Decode,

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<I>, I: 'static> Encode for XpState<T, I>

where T::Xp: Encode, T::Pulse: Encode, XpEligibility<T, I>: Encode,

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<I>, I: 'static> MaxEncodedLen for XpState<T, I>

where T::Xp: MaxEncodedLen, T::Pulse: MaxEncodedLen, XpEligibility<T, I>: MaxEncodedLen,

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 for XpState<T, I>

where T::Xp: PartialEq, T::Pulse: PartialEq,

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

where T::Xp: TypeInfo + 'static, T::Pulse: TypeInfo + 'static, XpEligibility<T, I>: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = XpState<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> DecodeWithMemTracking for XpState<T, I>

where T::Xp: DecodeWithMemTracking, T::Pulse: DecodeWithMemTracking, XpEligibility<T, I>: DecodeWithMemTracking,

impl<T: Config<I>, I: 'static> EncodeLike for XpState<T, I>

where T::Xp: Encode, T::Pulse: Encode, XpEligibility<T, I>: Encode,

impl<T: Eq + Config<I>, I: Eq + 'static> Eq for XpState<T, I>

where T::Xp: Eq, T::Pulse: Eq,

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