Enum ShareResolution 

pub enum ShareResolution<P, A> {
    RecoveredSsa(RecoveredSsa<P, A>),
    AlmostRecoveredSsa(SsaId<P>),
    Progress(SsaRecoveryProgress<P>),
    InvalidShares {
        peer: Box<OffchainPublicKey>,
        ssa_id: SsaId<P>,
        observed_total: u64,
    },
}

Possible resolutions of a received acknowledgement that might be bound to decrypt an encrypted PIX share.

P is the pseudonym type, A is the private key type for SSA.

Ordering and multiplicity within one batch

acknowledge_shares emits at most one Progress and at most one InvalidShares per SSA per call, and orders them ahead of the terminal AlmostRecoveredSsa/RecoveredSsa for the same SSA. A consumer can therefore act on a terminal event knowing the counters it would have wanted first have already been delivered.

Variants

RecoveredSsa(RecoveredSsa<P, A>)

Full SSA was recovered.

AlmostRecoveredSsa(SsaId<P>)

The early recovery threshold was reached (SSA almost complete).

Progress(SsaRecoveryProgress<P>)

Absolute recovery progress for one SSA after this batch.

InvalidShares

Invalid (unverifiable) shares were encountered for an SSA.

observed_total is the cross-peer aggregate for the SSA, not a delta and not this peer’s share of it: the cycle is a single unit of accounting and any relayer can carry shares for it. peer identifies who relayed the share that triggered this emission, for attribution only.

Fields

peer: Box<OffchainPublicKey>

Relayer whose acknowledgement carried the offending share.

ssa_id: SsaId<P>

SSA the offending share belongs to.

observed_total: u64

Total invalid shares seen for this SSA across all peers.

Implementations

impl<P, A> ShareResolution<P, A>

pub fn try_as_recovered_ssa(self) -> Option<RecoveredSsa<P, A>>

pub const fn try_as_recovered_ssa_ref(&self) -> Option<&RecoveredSsa<P, A>>

pub fn try_as_recovered_ssa_mut(&mut self) -> Option<&mut RecoveredSsa<P, A>>

pub fn try_as_almost_recovered_ssa(self) -> Option<SsaId<P>>

pub const fn try_as_almost_recovered_ssa_ref(&self) -> Option<&SsaId<P>>

pub fn try_as_almost_recovered_ssa_mut(&mut self) -> Option<&mut SsaId<P>>

pub fn try_as_progress(self) -> Option<SsaRecoveryProgress<P>>

pub const fn try_as_progress_ref(&self) -> Option<&SsaRecoveryProgress<P>>

pub fn try_as_progress_mut(&mut self) -> Option<&mut SsaRecoveryProgress<P>>

Trait Implementations

impl<P: Clone, A: Clone> Clone for ShareResolution<P, A>

fn clone(&self) -> ShareResolution<P, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug, A> Debug for ShareResolution<P, A>

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

Formats the value using the given formatter.

impl<P: Eq, A> Eq for ShareResolution<P, A>

impl<P: Hash, A> Hash for ShareResolution<P, A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P: PartialEq, A> PartialEq for ShareResolution<P, A>

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

Equality operator ==.

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

Inequality operator !=.