Struct RegisteredCycle 

struct RegisteredCycle<S: PixSpec> {
    cycle: SsaCycle<S>,
    registration: Arc<RegisteredCommitment<S>>,
}

A published cycle paired with the same retirement state as its commitment registration.

Fields

cycle: SsaCycle<S>

registration: Arc<RegisteredCommitment<S>>

Methods from Deref<Target = SsaCycle<S>>

pub fn num_polys(&self) -> usize

Number of polynomials this cycle is composed of.

pub fn record_useful_share(&self)

Records a share that advanced reconstruction — both a useful share and a share seen.

shares_seen first, so that in program order the counters never pass through a state where useful_shares leads. SsaRecoveryProgress::shares_seen promises to be at least useful_shares, and a consumer computing the surplus as the difference would otherwise underflow a u64 on the intermediate state. The two are separate Relaxed atomics, so this alone does not settle what another thread observes — progress clamps for that — but it removes the window rather than only papering over it.

pub fn record_surplus_share(&self)

Records a share that arrived for an already-reconstructed polynomial.

Liveness only: the surplus a conforming Entry emits advances nothing, but it is still evidence that the Entry is serving this cycle, which is what the Exit’s egress gate and recovery-idle deadline are asking about.

pub fn record_completed_part(&self)

Records a polynomial part that reconstructed and opened its commitment.

pub fn record_invalid_share(&self) -> u64

Records a share that failed verification, returning the cycle’s total afterwards.

pub fn progress(&self) -> SsaRecoveryProgress<S::Pseudonym>

Absolute recovery progress for this cycle.

The two share counters are independent Relaxed atomics, so a reader can observe them in either order regardless of the order they were written in. useful_shares is loaded first and shares_seen clamped up to it, which is what actually makes SsaRecoveryProgress::shares_seen’s “always at least useful_shares” a contract rather than a description: a consumer deriving the surplus as the difference cannot underflow. The clamp is engaged only for the instant a concurrent record_useful_share is mid-flight, and overstates shares_seen by at most the number of such writers.

pub fn credit_surplus(&self, poly_index: PolynomialIndex) -> Option<bool>

Consumes one negotiated surplus slot for poly_index.

Called only after SsaPartBuilder::add_share has decoded and validated the share as a post-reconstruction candidate. None means the untrusted polynomial index is out of range; Some(false) means the Entry has exhausted this polynomial’s own budget.

pub(crate) fn recovered_tail(&self) -> RecoveredSsaTail

Produces the compact state that survives full recovery while buffered SURBs drain.

pub fn part( &self, poly_index: PolynomialIndex, ) -> Option<&Mutex<SsaPartBuilder<S>>>

The part builder for one polynomial, or None if the index is out of range.

The index originates from a peer-supplied share, so this is a checked lookup and must stay one.

pub fn builder(&self) -> &Mutex<SsaBuilder<S>>

The accumulator that sums recovered parts into the SSA scalar.

Trait Implementations

impl<S: PixSpec> Deref for RegisteredCycle<S>

type Target = SsaCycle<S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.