Struct RangeFrame 

pub struct RangeFrame {
    pub offset: u64,
    pub length: u64,
    pub bytes: Vec<u8>,
    pub complete: bool,
    pub total_length: Option<u64>,
    pub chunk_lens: Option<Vec<u64>>,
    pub chunk_index: Option<u64>,
    pub inclusion_proof: Option<String>,
    pub root: Option<String>,
}

One streamed dig.fetchRange frame (L7 spec §8 framing). Frames arrive in ascending offset order and tile the requested range exactly; the caller reassembles by offset and stops on complete. The first frame additionally carries the per-range verification metadata so a single-peer range is independently verifiable against the chain-anchored root.

Fields

offset: u64

This frame’s start offset within the requested range.

length: u64

This frame’s byte length.

bytes: Vec<u8>

The raw ciphertext bytes. On the wire they are base64 (base64_bytes) — the canonical dig.fetchRange frame encoding every producer emits.

complete: bool

Whether this is the final frame of the range.

total_length: Option<u64>

(first frame only) the full resource ciphertext length.

chunk_lens: Option<Vec<u64>>

(first frame only) per-chunk ciphertext lengths of the whole resource, in order.

chunk_index: Option<u64>

(first frame only) index into chunk_lens of the first chunk in this frame.

inclusion_proof: Option<String>

(first frame only) merkle inclusion proof of the whole resource vs the generation root (base64, relayed verbatim); null/absent for capsule: true (self-verifying on install).

root: Option<String>

(first frame only) the generation root (64-hex) the inclusion proof is against.

Implementations

impl RangeFrame

pub fn encode(&self) -> Result<Vec<u8>>

Serialize as a u32 big-endian length prefix + JSON body (one framed frame on the stream).

Fails with io::ErrorKind::InvalidData if bytes exceeds MAX_RANGE_FRAME_PAYLOAD, or if the serialized body exceeds MAX_FRAMED_BODY for any other reason (an unusually large chunk_lens table or proof). A serving peer therefore cannot emit a frame decode is required to reject: it splits its resource on MAX_RANGE_FRAME_PAYLOAD or it learns about it here, at the send site, with the ceiling named in the error.

The payload is checked separately from the body because the body check alone is too weak: a payload well over the ceiling still fits in MAX_FRAMED_BODY once base64’d when the frame carries no metadata, so it would encode here and then overflow the moment the same span rode a FIRST frame with a chunk table attached — a size-dependent, intermittent failure. One explicit ceiling on bytes makes the limit the same for every frame.

pub async fn decode<R: AsyncRead + Unpin>(r: &mut R) -> Result<Option<Self>>

Read + decode one RangeFrame from r. Returns Ok(None) at clean end-of-stream (the reader hit EOF on a frame boundary), so a consumer loops until None or complete.

Trait Implementations

impl Clone for RangeFrame

fn clone(&self) -> RangeFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RangeFrame

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RangeFrame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RangeFrame

impl PartialEq for RangeFrame

fn eq(&self, other: &RangeFrame) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RangeFrame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RangeFrame