Struct ProvenBalance 

#[non_exhaustive]
pub struct ProvenBalance<const P: u8 = 2> {
    pub head: TreeHead,
    pub account: AccountPath,
    pub handle: AccountHandle,
    pub kind: AccountKind,
    pub period: PeriodId,
    pub start: Date,
    pub end: Date,
    pub seal_position: u64,
    pub currency: Currency,
    pub layer: Layer,
    pub balance: Balance<P>,
}

An account’s sealed balance proven against a log head — what SealedBalanceProof::verify and a verified balance bundle (Proven::Balance) establish: the seal is in the head, the balance is the leaf at the account’s handle in the seal’s tree, and the registration in the head names the handle.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

head: TreeHead

The head it is proven against.

account: AccountPath

The account’s path, from its registration.

handle: AccountHandle

The account’s handle.

kind: AccountKind

The account’s kind.

period: PeriodId

The sealed period’s id.

start: Date

The period’s first day.

end: Date

The period’s last day.

seal_position: u64

The seal’s log position.

currency: Currency

The currency.

layer: Layer

The layer.

balance: Balance<P>

The gross balance through the period’s end; its net is derived. A zero balance proven by the absence of a tree does not bind currency and layer: it is no evidence the currency was ever used.

Trait Implementations

impl<const P: u8> Clone for ProvenBalance<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const P: u8> Debug for ProvenBalance<P>

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

Formats the value using the given formatter.

impl<const P: u8> Eq for ProvenBalance<P>

impl<const P: u8> PartialEq for ProvenBalance<P>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const P: u8> StructuralPartialEq for ProvenBalance<P>