Struct SessionSsaState 

struct SessionSsaState {
    params: PixParams,
    committed_ssa_watermark: AtomicU32,
    returned_at_first_commit: AtomicU64,
    sent_deposit_data: Arc<Mutex<HashMap<SsaIndex, HoprPixDepositPayload>>>,
}

The PIX dimensions this Session negotiated, on the Exit side.

Once carried the SSA index and a fault counter as well. Both moved to the supervisor: it decides when a cycle is requested, so it is also what allocates the index, and it is what enforces the fault limit. Leaving a second copy of either here would have meant two authorities for one fact.

Fields

params: PixParams

The dimensions this Session negotiated, as they went on the wire.

committed_ssa_watermark: AtomicU32

Highest SSA index this Session has had the generator commit to, 0 before the first batch.

A deliberate second copy of a fact the generator already holds, and the only one of the three that came back. The generator’s own watermark lives in a cache with an idle retention, so “absent” there conflates never committed with state discarded — and those must not be treated alike, because the first is the opening batch every Session begins with and the second is a Session whose Entry can no longer serve the cycles it already committed to. This copy lives exactly as long as the Session does, so it can tell them apart. See the successor gate in SessionManager::handle_ssa_request.

Entry-side only; an Exit never commits and leaves it at zero. SsaIndex is a NonZero<u32>, which is what makes 0 an unambiguous “none” rather than a sentinel that has to be defended.

returned_at_first_commit: AtomicU64

SessionSlot::returned_packets as it stood when this Session first committed.

The successor gate counts service since that instant, not since the Session opened. Before the first commitment the generator holds no polynomials, so the SURBs going out carry no shares — and an Exit may legitimately be served up to max_predeposit_packets of them before any deposit exists. Crediting that prefix would let the Exit bank unpaid service against the first cycle it is paid for. Everything after this point rides a share.

sent_deposit_data: Arc<Mutex<HashMap<SsaIndex, HoprPixDepositPayload>>>

What this Exit sent as deposit data, per SSA index, for cycles whose deposit address it has not learned yet.

Implementations

impl SessionSsaState

pub fn new(params: PixParams) -> Self

pub fn remember_sent_deposit_data( &self, deposit_data: &HashMap<SsaIndex, HoprPixDepositPayload>, )

Files the deposit data of a batch the Exit is about to send, for take_sent_deposit_data to hand back once the matching deposit address is known.

pub fn take_sent_deposit_data( &self, session_id: &SessionId, ssa_index: SsaIndex, ) -> PixDepositData

Removes and returns what this Exit sent for ssa_index, or empty data if it sent none.

pub fn committed_watermark(&self) -> Option<SsaIndex>

Highest SSA index committed for this Session, None before the first batch.

pub fn note_committed(&self, index: SsaIndex, returned_packets: u64)

Raises the committed-index watermark to index if it is higher, taking the returned-packet baseline on the first commitment.

fetch_max rather than a store: the gate serialises requests per pseudonym, but a Session’s slot is shared and monotonicity here must not depend on that lock staying where it is. Its previous value is also what makes the baseline race-free without leaning on that lock — exactly one caller can observe a prior watermark of zero, so exactly one stores.

pub fn served_since_first_commit(&self, returned_packets: u64) -> u64

Exit → Entry packets received since this Session’s first commitment.

Saturating rather than wrapping: returned_packets is monotonic and the baseline is a past value of it, so an underflow is impossible — and if one ever became possible, reporting zero service closes the successor gate rather than opening it.

pub const fn quota_per_ssa(&self) -> u64

Data quota one SSA cycle of these dimensions covers.

The whole cycle, surplus included, as per pix_params_to_quota: every share a cycle emits rides one Exit → Entry packet, so all of them are priced.

Trait Implementations

impl Debug for SessionSsaState

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

Formats the value using the given formatter.