Struct CommitInfo

pub struct CommitInfo<T: Config<I>, I: 'static = ()> {
    digest: Digest<T>,
    commits: Commits<T, I>,
    variant: T::Position,
}

Represents a commitment associated with a specific digest and reason.

This structure tracks commitments at the lowest level. The referenced digest is intentionally unclassified and may correspond to a direct, index, or pool digest, as those are higher-level abstractions built over the same commitment model.

Each CommitInfo aggregates multiple CommitInstance values produced over time for the same (digest, reason) pair, representing successive commitments raised by the proprietor.

Fields

digest: Digest<T>

The target digest this commitment is associated with.

The digest is intentionally unclassified and may refer to a direct, index, or pool digest.

commits: Commits<T, I>

Collection of commit instances (CommitInstance) associated with this digest.

This collection is internally mutated via Commits::add_commit whenever new commit instances are appended.

variant: T::Position

The semantic disposition (variant) of the commitment (e.g. Affirmative, Contrary, etc).

This is semantically meaningful only for direct digests. For index and pool digests, this field acts as a structural placeholder, as those abstractions manage their own variant information through entries and slots respectively.

Implementations

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

pub(crate) fn new( digest: Digest<T>, instance: CommitInstance<T, I>, variant: T::Position, ) -> Result<Self, DispatchError>

Creates a new CommitInfo with an initial commit instance.

This constructor initializes the internal Commits collection in a controlled manner and establishes the initial commitment state for the given digest and reason.

pub fn commits(&self) -> WeakBoundedVec<CommitInstance<T, I>, T::MaxCommits>

Returns the individual commit instances of the proprietor.

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

Returns the digest proprietor committed to.

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

Returns the digest’s variant proprietor committed to.

pub(crate) fn add_commit( &mut self, instance: CommitInstance<T, I>, ) -> Result<(), DispatchError>

Adds a new commitment instance to the existing commits collection of the proprietor’s commit-info for a digest.

Returns DispatchError if the bounded vector capacity is exhausted.

Trait Implementations

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

where T::Position: Clone,

fn clone(&self) -> CommitInfo<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 CommitInfo<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 CommitInfo<T, I>

where Digest<T>: Decode, Commits<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 CommitInfo<T, I>

where Digest<T>: Encode, Commits<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> MaxEncodedLen for CommitInfo<T, I>

where Digest<T>: MaxEncodedLen, Commits<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: PartialEq + Config<I>, I: PartialEq + 'static> PartialEq for CommitInfo<T, I>

where T::Position: PartialEq,

fn eq(&self, other: &CommitInfo<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 CommitInfo<T, I>

where Digest<T>: TypeInfo + 'static, Commits<T, I>: TypeInfo + 'static, T::Position: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

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

where Digest<T>: DecodeWithMemTracking, Commits<T, I>: DecodeWithMemTracking, T::Position: DecodeWithMemTracking,

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

where Digest<T>: Encode, Commits<T, I>: Encode, T::Position: Encode,

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

where T::Position: Eq,

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