Struct Ack 

pub struct Ack<S: Scheme, D: Digest> {
    pub item: Item<D>,
    pub epoch: Epoch,
    pub attestation: Attestation<S>,
}

Acknowledgment (ack) represents a validator’s vote on an item. Multiple acks can be recovered into a certificate for consensus.

Fields

item: Item<D>

The item being acknowledged

epoch: Epoch

The epoch in which this acknowledgment was created.

Not part of the signed message: it selects the scheme used to verify the attestation and assemble a certificate. See the module docs.

attestation: Attestation<S>

Scheme-specific attestation material

Implementations

impl<S: Scheme, D: Digest> Ack<S, D>

pub fn verify<R>( &self, rng: &mut R, scheme: &S, strategy: &impl Strategy, ) -> bool

where R: CryptoRng, S: Scheme<D>,

Verifies the attestation on this acknowledgment.

Returns true if the attestation is valid for the given namespace and public key. Domain separation is automatically applied to prevent signature reuse.

pub fn sign(scheme: &S, epoch: Epoch, item: Item<D>) -> Option<Self>

where S: Scheme<D>,

Creates a new acknowledgment by signing an item with a validator’s key.

The signature uses domain separation to prevent cross-protocol attacks. The epoch is carried in the ack but is not part of the signed message. See the module docs.

Determinism

Signatures produced by this function are deterministic and safe for consensus.

Trait Implementations

impl<S: Clone + Scheme, D: Clone + Digest> Clone for Ack<S, D>

fn clone(&self) -> Ack<S, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Scheme, D: Debug + Digest> Debug for Ack<S, D>

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

Formats the value using the given formatter.

impl<S: Scheme, D: Digest> EncodeSize for Ack<S, D>

fn encode_size(&self) -> usize

Returns the encoded size of this value (in bytes).

fn encode_inline_size(&self) -> usize

Returns the encoded size excluding bytes passed to BufsMut::push during Write::write_bufs. Used to size the working buffer for inline writes. Override alongside Write::write_bufs for types where large Bytes fields go via push; failing to do so will over-allocate.

impl<S: Eq + Scheme, D: Eq + Digest> Eq for Ack<S, D>

impl<S: Hash + Scheme, D: Hash + Digest> Hash for Ack<S, D>

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<S: PartialEq + Scheme, D: PartialEq + Digest> PartialEq for Ack<S, D>

fn eq(&self, other: &Ack<S, D>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<S: Scheme, D: Digest> Read for Ack<S, D>

type Cfg = ()

The Cfg type parameter allows passing configuration during the read process. This is crucial for safely decoding untrusted data, for example, by providing size limits for collections or strings.

fn read_cfg(reader: &mut impl Buf, _: &()) -> Result<Self, CodecError>

Reads a value from the buffer using the provided configuration cfg.

impl<S: PartialEq + Scheme, D: PartialEq + Digest> StructuralPartialEq for Ack<S, D>

impl<S: Scheme, D: Digest> Write for Ack<S, D>

fn write(&self, writer: &mut impl BufMut)

Writes the binary representation of self to the provided buffer buf.

fn write_bufs(&self, buf: &mut impl BufsMut)

Writes to a BufsMut, allowing existing Bytes chunks to be appended via BufsMut::push instead of written inline. Must encode to the same format as Write::write. Defaults to Write::write.