Struct ProvenBlock 

pub struct ProvenBlock { /* private fields */ }

Represents a block in the Miden blockchain that has been signed and proven.

Blocks transition through proposed, signed, and proven states. This struct represents the final, proven state of a block.

Proven blocks are the final, canonical blocks in the chain.

Implementations

impl ProvenBlock

pub fn new( header: BlockHeader, body: BlockBody, signature: Signature, proof: BlockProof, ) -> Result<Self, ProvenBlockError>

Returns a new ProvenBlock instantiated from the provided components.

Validates that the provided components correspond to each other by verifying the signature, and checking for matching transaction commitments and note roots.

Involves non-trivial computation. Use Self::new_unchecked if the validation is not necessary.

Note: this does not fully validate the consistency of provided components. Specifically, we cannot validate that:

• That applying the account updates in the block body to the account tree represented by the root from the previous block header would actually result in the account root in the provided header.
• That inserting the created nullifiers in the block body to the nullifier tree represented by the root from the previous block header would actually result in the nullifier root in the provided header.

Errors

Returns an error if:

• If the validator signature does not verify against the block header commitment and the validator key.
• If the transaction commitment in the block header is inconsistent with the transactions included in the block body.
• If the note root in the block header is inconsistent with the notes included in the block body.

pub fn new_unchecked( header: BlockHeader, body: BlockBody, signature: Signature, proof: BlockProof, ) -> Self

Returns a new ProvenBlock instantiated from the provided components.

Warning

This constructor does not do any validation as to whether the arguments correctly correspond to each other, which could cause errors downstream.

pub fn validate(&self) -> Result<(), ProvenBlockError>

Validates that the components of the proven block correspond to each other by verifying the signature, and checking for matching transaction commitments and note roots.

Validation involves non-trivial computation, and depending on the size of the block may take non-negligible amount of time.

Note: this does not fully validate the consistency of internal components. Specifically, we cannot validate that:

• That applying the account updates in the block body to the account tree represented by the root from the previous block header would actually result in the account root in the provided header.
• That inserting the created nullifiers in the block body to the nullifier tree represented by the root from the previous block header would actually result in the nullifier root in the provided header.

Errors

Returns an error if:

• If the validator signature does not verify against the block header commitment and the validator key.
• If the transaction commitment in the block header is inconsistent with the transactions included in the block body.
• If the note root in the block header is inconsistent with the notes included in the block body.

pub fn proof_security_level(&self) -> u32

Returns the proof security level of the block.

pub fn header(&self) -> &BlockHeader

Returns the header of the block.

pub fn body(&self) -> &BlockBody

Returns the body of the block.

pub fn signature(&self) -> &Signature

Returns the Validator’s signature over the block header.

pub fn proof(&self) -> &BlockProof

Returns the proof of the block.

pub fn into_parts(self) -> (BlockHeader, BlockBody, Signature, BlockProof)

Destructures this proven block into individual parts.

Trait Implementations

impl Clone for ProvenBlock

fn clone(&self) -> ProvenBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProvenBlock

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

Formats the value using the given formatter.

impl Deserializable for ProvenBlock

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl PartialEq for ProvenBlock

fn eq(&self, other: &ProvenBlock) -> 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 Serializable for ProvenBlock

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Eq for ProvenBlock

impl StructuralPartialEq for ProvenBlock