Struct MastForestWireView 

pub struct MastForestWireView<'a> { /* private fields */ }

A trusted wire-backed view over serialized MAST forest bytes.

This view accepts complete payloads with hashes. It validates the header and the fixed-width structural sections needed for random access, but it does not fully materialize the forest. Hashless payloads are rejected because trusted cache bytes must be complete. Trailing payloads are rejected because debug metadata now belongs to package-owned debug sections.

Use this when callers need random access to roots or node metadata without deserializing the full forest. For strict trusted deserialization, use crate::mast::MastForest::read_from_bytes.

Examples

use miden_core::{
    mast::{BasicBlockNodeBuilder, MastForest, MastForestContributor, MastForestWireView},
    operations::Operation,
    serde::Serializable,
};

let mut forest = MastForest::new();
let block_id = BasicBlockNodeBuilder::new(vec![Operation::Add])
    .add_to_forest(&mut forest)
    .unwrap();
forest.make_root(block_id);

let mut bytes = Vec::new();
forest.write_into(&mut bytes);

let view = MastForestWireView::new(&bytes).unwrap();
assert_eq!(view.node_count(), forest.nodes().len());
assert!(view.node_info_at(0).is_ok());

Implementations

impl<'a> MastForestWireView<'a>

pub fn new( bytes: &'a [u8], ) -> Result<MastForestWireView<'a>, DeserializationError>

Creates a new view from serialized bytes.

The input must include all node hashes. Structural parsing is delegated to the same single-pass scanner used by reader-based deserialization paths.

This constructor validates the header and sections needed for node/roots/random-access metadata, indexes AdviceMap keys for on-demand lookup, and rejects trailing payloads.

Treat this as a trusted cache API, not as an untrusted-validation entry point. It is appropriate for local tools that need random access over serialized structure, but callers handling adversarial bytes should use crate::mast::UntrustedMastForest instead.

In particular, this constructor does not protect callers from untrusted-input concerns that are enforced by crate::mast::UntrustedMastForest::validate. It does not:

• verify that serialized non-external digests match the structure they describe
• check topological ordering / forward-reference constraints
• validate basic-block batch invariants
• materialize or expose package-owned debug sections

For strict materialized validation, use crate::mast::MastForest::read_from_bytes.

Digest lookup follows the wire layout:

• Non-external node digests are read from the internal-hash section.
• External node digests are read from the external-digest section.

Examples

use miden_core::{
    mast::{BasicBlockNodeBuilder, MastForest, MastForestContributor, MastForestWireView},
    operations::Operation,
    serde::Serializable,
};

let mut forest = MastForest::new();
let block_id = BasicBlockNodeBuilder::new(vec![Operation::Add])
    .add_to_forest(&mut forest)
    .unwrap();
forest.make_root(block_id);

let mut bytes = Vec::new();
forest.write_into(&mut bytes);

let view = MastForestWireView::new(&bytes).unwrap();
assert_eq!(view.node_count(), 1);

pub fn node_count(&self) -> usize

Returns the number of nodes in the serialized forest.

pub fn procedure_root_count(&self) -> usize

Returns the number of procedure roots in the serialized forest.

pub fn procedure_root_at( &self, index: usize, ) -> Result<MastNodeId, DeserializationError>

Returns the procedure root id at the specified index.

Returns an error if index >= self.procedure_root_count().

pub fn node_info_at( &self, index: usize, ) -> Result<MastNodeInfo, DeserializationError>

Returns the MastNodeInfo at the specified index.

Returns an error if index >= self.node_count().

Examples

use miden_core::{
    mast::{BasicBlockNodeBuilder, MastForest, MastForestContributor, MastForestWireView},
    operations::Operation,
    serde::Serializable,
};

let mut forest = MastForest::new();
let block_id = BasicBlockNodeBuilder::new(vec![Operation::Add])
    .add_to_forest(&mut forest)
    .unwrap();
forest.make_root(block_id);

let mut bytes = Vec::new();
forest.write_into(&mut bytes);

let view = MastForestWireView::new(&bytes).unwrap();
assert!(view.node_info_at(0).is_ok());

pub fn node_entry_at( &self, index: usize, ) -> Result<MastNodeEntry, DeserializationError>

Returns the fixed-width structural node entry at the specified index.

Returns an error if index >= self.node_count().

pub fn node_digest_at(&self, index: usize) -> Result<Word, DeserializationError>

Returns the digest for the node at the specified index.

Returns an error if index >= self.node_count().

pub fn advice_map(&self) -> AdviceMapView<'_>

Returns a read-only view over the serialized forest advice map.

Trait Implementations

impl<'a> Debug for MastForestWireView<'a>

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

Formats the value using the given formatter.

impl MastForestView for MastForestWireView<'_>

fn node_count(&self) -> usize

Returns the number of nodes in the forest.

fn node_entry_at( &self, index: usize, ) -> Result<MastNodeEntry, DeserializationError>

Returns fixed-width structural metadata for a node at the specified index.

fn node_digest_at(&self, index: usize) -> Result<Word, DeserializationError>

Returns the digest of the node at the specified index.

fn procedure_root_count(&self) -> usize

Returns the number of procedure roots in the forest.

fn procedure_root_at( &self, index: usize, ) -> Result<MastNodeId, DeserializationError>

Returns the procedure root id at the specified index.

fn advice_map(&self) -> AdviceMapView<'_>

Returns a read-only view over the forest advice map.

fn node_info_at( &self, index: usize, ) -> Result<MastNodeInfo, DeserializationError>

Returns serialized-equivalent metadata for a node at the specified index.

fn is_empty(&self) -> bool

Returns true when the forest contains no nodes.

fn has_node(&self, index: usize) -> bool

Returns true when index is a valid node index.

fn all_node_infos(&self) -> Result<Vec<MastNodeInfo>, DeserializationError>

Returns all node infos in index order.

fn procedure_roots(&self) -> Result<Vec<MastNodeId>, DeserializationError>

Returns all procedure roots in index order.