Struct SsaServerCommitmentMessage 

pub struct SsaServerCommitmentMessage<I, G, D> {
    pub session_id: I,
    pub params: u32,
    pub deposit_data: HashMap<SsaIndex, D>,
    pub commitments: BTreeMap<SsaIndex, G>,
    pub missing: BTreeMap<SsaIndex, Vec<PolynomialRun>>,
}

Sent by the Server either to deliver the commitment to new Session Stealth Addresses (SSAs), or to ask for the parts of an earlier commitment it never received.

The first kind is typically sent right after the StartEstablished message if PIX capabilities are indicated in the StartInitiation message and the Server accepts it, and then again every time the Server needs the next batch of SSAs (with indices strictly greater than in the last batch) to be committed to.

The second kind exists because the Client’s answer to the first is not one message but hundreds, and the Server can use none of it until every one of them has landed. It names the gaps in missing and asks for nothing new; see there.

Exactly one of commitments and missing is populated, which is what makes the two kinds impossible to confuse — Self::new and Self::recommit each build one of them, and both encoding and decoding refuse a message that is neither.

Fields

session_id: I

Session ID.

params: u32

Parameters of the PIX protocol the server requires, packed by PixParams::to_u32.

deposit_data: HashMap<SsaIndex, D>

Per-SSA deposit/payment data, carried in CBOR as a single map keyed by the same SsaIndex as commitments.

Empty on a retransmission request: it asks for no new SSA, and the deposit data of the cycles it names was delivered when they were first requested.

commitments: BTreeMap<SsaIndex, G>

Server’s serialized commitments to the SSAs, ordered by the SSA index.

Empty on a retransmission request — see the type-level documentation.

missing: BTreeMap<SsaIndex, Vec<PolynomialRun>>

Polynomial-index runs whose commitments the Server never received, per SSA.

Empty on a request for new SSAs. Non-empty makes this a retransmission request: the Server is asking the Client to re-send the commitments it names for cycles it has already committed to, and nothing else. Nothing new is requested, no deposit follows, and the Client must not announce one — the deposit address of a cycle is fixed when it is first committed.

The runs of one SSA are ascending and disjoint, which the decoder enforces: it makes the scope canonical, bounds the indices one request can name at the cycle’s polynomial count, and lets the answer be assembled without deduplicating.

Implementations

impl<I, G, D> SsaServerCommitmentMessage<I, G, D>

pub fn new( session_id: I, params: PixParams, commitments: impl IntoIterator<Item = (SsaIndex, G)>, deposit_data: impl IntoIterator<Item = (SsaIndex, D)>, ) -> Self

Convenience constructor for creating a new SsaServerCommitmentMessage.

pub fn recommit( session_id: I, params: PixParams, missing: impl IntoIterator<Item = (SsaIndex, Vec<PolynomialRun>)>, ) -> Self

Asks the Client to re-send the commitments of polynomial runs the Server never received.

A constructor of its own rather than a field to fill in, so the two request kinds cannot be mixed: this one carries no commitments and no deposit data, which is the invariant the codec enforces. params is echoed so the recipient can check the request against what was negotiated, exactly as it does for a request for new SSAs.

The caller is responsible for keeping the runs of each SSA ascending and disjoint, and for naming no more of them than StartProtocol::max_missing_runs allows.

pub fn missing_run_count(&self) -> usize

Total number of polynomial runs this request names, across every SSA.

The wire form is a flat table, so this — not the number of SSAs — is what has to fit a packet.

pub fn dimensions(&self) -> Result<PixParams>

The PIX dimensions this request was made under, and the curve suite they are dimensions of.

Fails if the peer packed values outside the protocol ranges, or named a curve suite that does not exist. The name predates the suite and is kept because the callers read it for the dimensions; the suite rides along because both sides must agree on it too.

Trait Implementations

impl<I: Clone, G: Clone, D: Clone> Clone for SsaServerCommitmentMessage<I, G, D>

fn clone(&self) -> SsaServerCommitmentMessage<I, G, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, G: Debug, D: Debug> Debug for SsaServerCommitmentMessage<I, G, D>

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

Formats the value using the given formatter.

impl<I: Eq, G: Eq, D: Eq> Eq for SsaServerCommitmentMessage<I, G, D>

impl<I: PartialEq, G: PartialEq, D: PartialEq> PartialEq for SsaServerCommitmentMessage<I, G, D>

fn eq(&self, other: &SsaServerCommitmentMessage<I, G, D>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I: PartialEq, G: PartialEq, D: PartialEq> StructuralPartialEq for SsaServerCommitmentMessage<I, G, D>