Struct ProofCarryingChunk 

pub struct ProofCarryingChunk { /* private fields */ }

Represents a Chunk augmented with a Merkle proof of its inclusion in the original blob. This structure is used for verifiable data retrieval and reconstruction.

Implementations

impl ProofCarryingChunk

pub fn validate_inclusion_in_blob(&self, blob_commitment: Hash) -> bool

Validates the inclusion of this chunk in the overall blob using the provided blob root commitment.

This method verifies the Merkle proof against the blob’s root commitment, assuming the proof contains the necessary sibling nodes to ascend to the blob root.

Meaning Self::append_proof_to_blob_root() needs to be called after Self::new() to extend the Merkle inclusion proof to the blob root level - only then one can validate inclusion of this chunk in the blob.

Arguments

• blob_commitment - The blake3::Hash of the root of the Merkle tree for the entire blob.

Returns

Returns true if the chunk’s inclusion proof in the blob is valid, false otherwise.

pub fn validate_inclusion_in_chunkset(&self, chunkset_commitment: Hash) -> bool

Validates the inclusion of this chunk within its specific chunkset using the provided chunkset root commitment.

This method checks the Merkle proof against the chunkset’s root commitment.

Arguments

• chunkset_commitment - The blake3::Hash of the root of the Merkle tree for the chunkset this chunk belongs to.

Returns

Returns true if the chunk’s inclusion proof in its chunkset is valid, false otherwise.

pub fn get_chunkset_id(&self) -> usize

Returns the ID of the chunkset this chunk belongs to.

pub fn get_global_chunk_id(&self) -> usize

Returns the global ID of the chunk.

pub fn get_local_chunk_id(&self) -> usize

Returns the local ID of the chunk.

pub fn get_erasure_coded_data(&self) -> &[u8]

Returns a reference to the erasure-coded data contained within the chunk.

pub fn append_proof_to_blob_root(&mut self, blob_proof: &[Hash])

Appends additional Merkle proof hashes to the existing proof, proving blob-level inclusion.

This is used to extend a chunkset-level proof to a blob-level proof. You are supposed to call this function after Self::new is used to contruct a new proof-carrying chunk, which originally holds a proof of inclusion in the corresponding chunkset.

Arguments

• blob_proof - A slice of blake3::Hash representing the proof to append.

pub fn to_bytes(&self) -> Result<Vec<u8>, DecdsError>

Serializes the ProofCarryingChunk into a vector of bytes using bincode.

Returns

Returns a Result which is:

• Ok(Vec<u8>) containing the serialized bytes if successful.
• Err(DecdsError::ProofCarryingChunkSerializationFailed) if serialization fails.

pub fn from_bytes(bytes: &[u8]) -> Result<(Self, usize), DecdsError>

Deserializes a ProofCarryingChunk from a byte slice using bincode.

Arguments

• bytes - The byte slice from which to deserialize the chunk.

Returns

Returns a Result which is:

• Ok((Self, usize)) containing the deserialized ProofCarryingChunk and the number of bytes read if successful.
• Err(DecdsError::ProofCarryingChunkDeserializationFailed) if deserialization fails.

Trait Implementations

impl Clone for ProofCarryingChunk

fn clone(&self) -> ProofCarryingChunk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofCarryingChunk

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProofCarryingChunk

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProofCarryingChunk

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProofCarryingChunk

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 ProofCarryingChunk