Struct SubtreePrefetchRequest 

pub struct SubtreePrefetchRequest {
    pub subtree_roots: Vec<[u8; 32]>,
    /* private fields */
}

Request for subtree prefetch-based sync.

Fetches entire subtrees when divergence is detected in deep trees. More efficient than HashComparison when changes are clustered.

Use when:

• tree depth > DEEP_TREE_THRESHOLD (3)
• divergence < MAX_DIVERGENCE_RATIO (20%)
• Changes are clustered in <= MAX_CLUSTERED_SUBTREES (5) subtrees

Fields

subtree_roots: Vec<[u8; 32]>

Root hashes of subtrees to fetch.

Limited to MAX_SUBTREES_PER_REQUEST entries. Use is_valid() to check bounds after deserialization from untrusted sources.

Implementations

impl SubtreePrefetchRequest

pub fn new(subtree_roots: Vec<[u8; 32]>) -> Self

Create a new subtree prefetch request.

pub fn with_depth(subtree_roots: Vec<[u8; 32]>, max_depth: usize) -> Self

Create a request with custom depth limit.

Depth is clamped to MAX_SUBTREE_DEPTH to prevent resource exhaustion.

pub fn unlimited_depth(subtree_roots: Vec<[u8; 32]>) -> Self

Create a request with maximum allowed depth (MAX_SUBTREE_DEPTH).

Use this when you want to fetch as deep as safely possible. The depth() accessor will return MAX_SUBTREE_DEPTH.

pub fn depth(&self) -> usize

Get the validated depth limit.

Always returns a bounded value:

• Clamps to MAX_SUBTREE_DEPTH if the raw value exceeds it
• Returns MAX_SUBTREE_DEPTH if max_depth is None

This ensures consumers always get a safe, bounded depth value regardless of how the request was constructed or deserialized.

pub fn is_unlimited(&self) -> bool

Check if this request was created with unlimited depth.

Returns true if created via unlimited_depth() constructor. Note: depth() will still return MAX_SUBTREE_DEPTH for safety.

pub fn subtree_count(&self) -> usize

Number of subtrees requested.

pub fn is_empty(&self) -> bool

Check if this is an empty request (no subtrees).

pub fn is_valid(&self) -> bool

Check if request is within valid bounds.

Call this after deserializing from untrusted sources to prevent resource exhaustion attacks. Validates:

• subtree_roots count <= MAX_SUBTREES_PER_REQUEST
• max_depth (if Some) <= MAX_SUBTREE_DEPTH

Trait Implementations

impl BorshDeserialize for SubtreePrefetchRequest

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for SubtreePrefetchRequest

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for SubtreePrefetchRequest

fn clone(&self) -> SubtreePrefetchRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubtreePrefetchRequest

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

Formats the value using the given formatter.

impl PartialEq for SubtreePrefetchRequest

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