Struct SlotInfo

pub struct SlotInfo<T: Config<I>, I: 'static = ()> {
    digest: SlotDigest<T>,
    shares: T::Shares,
    commit: CommitInstance<T, I>,
    variant: T::Position,
}

Represents a slot within a pool, derived from an index entry.

A SlotInfo tracks the underlying digest, the allocated shares, the slot’s single CommitInstance (a collective receipt) and the variant/disposition. It is primarily used when creating or managing pools derived from index entries.

Fields

digest: SlotDigest<T>

Unique identifier for the slot

shares: T::Shares

Shares allocated to this slot

commit: CommitInstance<T, I>

Commit-Instance associated with this slot

Since pools collectively manages funds, slots also inherit such behaviour. Hence it acts similar to a proprietor holding a deposit receipt from digest for their commitment.

variant: T::Position

Disposition of this slot (e.g., Affirmative, Contrary, Awaiting)

Implementations

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

pub fn shares(&self) -> T::Shares

Returns the pool’s slot’s total shares.

pub fn commit(&self) -> CommitInstance<T, I>

Returns the pool’s slot’s commit-instance (as a pseudo-proprietor).

pub fn digest(&self) -> SlotDigest<T>

Returns the pool’s slot’s digest.

pub fn variant(&self) -> T::Position

Returns the pool’s slot’s variant.

fn set_slot_commit(&mut self, commit: CommitInstance<T, I>)

Updates the CommitInstance associated with this slot.

This method replaces the existing commit instance with the provided one. It does not perform any validation, aggregation, or merging of commits, the caller is responsible for ensuring correctness and consistency.

Parameters

• commit: The new CommitInstance to associate with this slot.

Invariants

• This operation assumes the slot is already initialized.
• The provided commit should be semantically valid for this slot’s digest, shares, and variant.

Note

This is an internal mutation helper and is not intended to enforce higher-level commitment rules.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config<I>, I: 'static> Debug for SlotInfo<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for SlotInfo<T, I>

where SlotDigest<T>: Decode, T::Shares: Decode, CommitInstance<T, I>: Decode, T::Position: 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 SlotInfo<T, I>

where SlotDigest<T>: Encode, T::Shares: Encode, CommitInstance<T, I>: Encode, T::Position: 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> From<EntryInfo<T, I>> for SlotInfo<T, I>

fn from(entry: EntryInfo<T, I>) -> Self

Converts an EntryInfo into a SlotInfo.

This is used when creating a pool from an index, as each index entry corresponds to a pool slot. The deposit-receipt is initialized to empty as slot doesn’t hold a commit currently.

Returns

A SlotInfo with the same digest, shares, and variant.

impl<T: Config<I>, I: 'static> MaxEncodedLen for SlotInfo<T, I>

where SlotDigest<T>: MaxEncodedLen, T::Shares: MaxEncodedLen, CommitInstance<T, I>: MaxEncodedLen, T::Position: MaxEncodedLen,

fn max_encoded_len() -> usize

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

impl<T: Config<I>, I: 'static> PartialEq for SlotInfo<T, I>

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

where SlotDigest<T>: TypeInfo + 'static, T::Shares: TypeInfo + 'static, CommitInstance<T, I>: TypeInfo + 'static, T::Position: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = SlotInfo<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 SlotInfo<T, I>

where SlotDigest<T>: DecodeWithMemTracking, T::Shares: DecodeWithMemTracking, CommitInstance<T, I>: DecodeWithMemTracking, T::Position: DecodeWithMemTracking,

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

where SlotDigest<T>: Encode, T::Shares: Encode, CommitInstance<T, I>: Encode, T::Position: Encode,

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