Enum Response 

pub enum Response<F: Family, Op, D: Digest> {
    Operations {
        proof: Proof<F, D>,
        operations: Vec<Op>,
    },
    Boundary {
        proof: Proof<F, D>,
        op: Op,
        pinned_nodes: Vec<D>,
    },
}

One authenticated response, shaped like the Request it answers.

In a Response::Boundary, the proof, the operation, and the pinned nodes are verified as a unit. The pinned nodes are only believable because the proof folds them into digests it already commits to.

Variants

Operations

Answer to a Request::Operations.

Fields

proof: Proof<F, D>

Proof authenticating operations against the root at the requested size.

operations: Vec<Op>

The operations that were fetched.

Boundary

Answer to a Request::Boundary.

Fields

proof: Proof<F, D>

Proof authenticating op against the root at the requested size.

op: Op

The operation at the requested boundary.

pinned_nodes: Vec<D>

Pinned nodes at the requested location.

Implementations

impl<F: Family, Op, D: Digest> Response<F, Op, D>

pub const fn proof(&self) -> &Proof<F, D>

The proof authenticating this response.

Trait Implementations

impl<F: Family, Op: Clone, D: Digest> Clone for Response<F, Op, D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Family, Op: Debug, D: Digest> Debug for Response<F, Op, D>

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

Formats the value using the given formatter.

impl<F: Family, Op: EncodeSize, D: Digest> EncodeSize for Response<F, Op, 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<F: Family, Op: Read, D: Digest> Read for Response<F, Op, D>

type Cfg = (usize, <Op as Read>::Cfg)

The max_ops the request asked for, and the configuration for decoding one operation.

fn read_cfg( buf: &mut impl Buf, (max_ops, op_cfg): &Self::Cfg, ) -> Result<Self, CodecError>

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

impl<F: Family, Op: Write, D: Digest> Write for Response<F, Op, D>

fn write(&self, buf: &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.