Struct MemoryStorage 

pub struct MemoryStorage {
    pub root: RwLock<Word>,
    pub leaves: RwLock<BTreeMap<u64, SmtLeaf>>,
    pub subtrees: RwLock<BTreeMap<NodeIndex, Subtree>>,
}

In-memory storage for a Sparse Merkle Tree (SMT), implementing the SmtStorage trait.

This structure stores the SMT’s root hash, leaf nodes, and subtrees directly in memory. Access to these components is synchronized using std::sync::RwLock for thread safety.

It is primarily intended for scenarios where data persistence to disk is not a primary concern. Common use cases include:

• Testing environments.
• Managing SMT instances with a limited operational lifecycle.
• Situations where a higher-level application architecture handles its own data persistence strategy.

Fields

root: RwLock<Word>

leaves: RwLock<BTreeMap<u64, SmtLeaf>>

subtrees: RwLock<BTreeMap<NodeIndex, Subtree>>

Implementations

impl MemoryStorage

pub fn new() -> MemoryStorage

Creates a new, empty in-memory storage for a Sparse Merkle Tree.

Initializes the root to the empty SMT root for the defined SMT_DEPTH, and empty maps for leaves and subtrees.

Trait Implementations

impl Clone for MemoryStorage

fn clone(&self) -> MemoryStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryStorage

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

Formats the value using the given formatter.

impl Default for MemoryStorage

fn default() -> MemoryStorage

Returns the “default value” for a type.

impl SmtStorage for MemoryStorage

fn get_root(&self) -> Result<Option<Word>, StorageError>

Retrieves the current root hash of the Sparse Merkle Tree.

fn set_root(&self, root: Word) -> Result<(), StorageError>

Sets the root hash of the Sparse Merkle Tree.

fn leaf_count(&self) -> Result<usize, StorageError>

Gets the total number of non-empty leaves currently stored.

fn entry_count(&self) -> Result<usize, StorageError>

Gets the total number of key-value entries currently stored.

fn insert_value( &self, index: u64, key: Word, value: Word, ) -> Result<Option<Word>, StorageError>

Inserts a key-value pair into the leaf at the given index.

• If the leaf at index does not exist, a new SmtLeaf::Single is created.
• If the leaf exists, the key-value pair is inserted into it.
• Returns the previous value associated with the key, if any.

Errors

Returns StorageError::Backend if the write lock cannot be acquired.

Panics

Panics in debug builds if value is EMPTY_WORD.

fn remove_value( &self, index: u64, key: Word, ) -> Result<Option<Word>, StorageError>

Removes a key-value pair from the leaf at the given index.

• If the leaf at index exists and the key is found within that leaf, the key-value pair is removed, and the old Word value is returned in Ok(Some(Word)).
• If the leaf at index exists but the key is not found within that leaf, Ok(None) is returned (as leaf.get_value(&key) would be None).
• If the leaf at index does not exist, Ok(None) is returned, as no value could be removed.

Errors

Returns StorageError::Backend if the write lock for leaves cannot be acquired.

fn get_leaf(&self, index: u64) -> Result<Option<SmtLeaf>, StorageError>

Retrieves a single leaf node.

fn set_leaves( &self, leaves_map: BTreeMap<u64, SmtLeaf>, ) -> Result<(), StorageError>

Sets multiple leaf nodes in storage.

If a leaf at a given index already exists, it is overwritten.

Errors

Returns StorageError::Backend if the write lock for leaves cannot be acquired.

fn remove_leaf(&self, index: u64) -> Result<Option<SmtLeaf>, StorageError>

Removes a single leaf node.

fn get_leaves( &self, indices: &[u64], ) -> Result<Vec<Option<SmtLeaf>>, StorageError>

Retrieves multiple leaf nodes. Returns Ok(None) for indices not found.

fn has_leaves(&self) -> Result<bool, StorageError>

Returns true if the storage has any leaves.

fn get_subtree(&self, index: NodeIndex) -> Result<Option<Subtree>, StorageError>

Retrieves a single Subtree (representing deep nodes) by its root NodeIndex. Assumes index.depth() >= IN_MEMORY_DEPTH. Returns Ok(None) if not found.

fn get_subtrees( &self, indices: &[NodeIndex], ) -> Result<Vec<Option<Subtree>>, StorageError>

Retrieves multiple Subtrees. Assumes index.depth() >= IN_MEMORY_DEPTH for all indices. Returns Ok(None) for indices not found.

fn set_subtree(&self, subtree: &Subtree) -> Result<(), StorageError>

Sets a single Subtree (representing deep nodes) by its root NodeIndex.

If a subtree with the same root NodeIndex already exists, it is overwritten. Assumes subtree.root_index().depth() >= IN_MEMORY_DEPTH.

Errors

Returns StorageError::Backend if the write lock for subtrees cannot be acquired.

fn set_subtrees(&self, subtrees_vec: Vec<Subtree>) -> Result<(), StorageError>

Sets multiple Subtrees (representing deep nodes) by their root NodeIndex.

If a subtree with a given root NodeIndex already exists, it is overwritten. Assumes subtree.root_index().depth() >= IN_MEMORY_DEPTH for all subtrees in the vector.

Errors

Returns StorageError::Backend if the write lock for subtrees cannot be acquired.

fn remove_subtree(&self, index: NodeIndex) -> Result<(), StorageError>

Removes a single Subtree (representing deep nodes) by its root NodeIndex.

fn get_inner_node( &self, index: NodeIndex, ) -> Result<Option<InnerNode>, StorageError>

Retrieves a single inner node from a Subtree.

This function is intended for accessing nodes within a Subtree, meaning index.depth() must be greater than or equal to IN_MEMORY_DEPTH.

Errors

• StorageError::Backend: If index.depth() < IN_MEMORY_DEPTH.
• StorageError::Backend: If the read lock for subtrees cannot be acquired.

Returns Ok(None) if the subtree or the specific inner node within it is not found.

fn set_inner_node( &self, index: NodeIndex, node: InnerNode, ) -> Result<Option<InnerNode>, StorageError>

Sets a single inner node within a Subtree.

• index.depth() must be greater than or equal to IN_MEMORY_DEPTH.
• If the target Subtree does not exist, it is created.
• The node is then inserted into the Subtree.

Returns the InnerNode that was previously at this index, if any.

Errors

• StorageError::Backend: If index.depth() < IN_MEMORY_DEPTH.
• StorageError::Backend: If the write lock for subtrees cannot be acquired.

fn remove_inner_node( &self, index: NodeIndex, ) -> Result<Option<InnerNode>, StorageError>

Removes a single inner node from a Subtree.

• index.depth() must be greater than or equal to IN_MEMORY_DEPTH.
• If the Subtree becomes empty after removing the node, the Subtree itself is removed from storage.

Returns the InnerNode that was removed, if any.

Errors

• StorageError::Backend: If index.depth() < IN_MEMORY_DEPTH.
• StorageError::Backend: If the write lock for subtrees cannot be acquired.

fn apply(&self, updates: StorageUpdates) -> Result<(), StorageError>

Applies a set of updates atomically to the storage.

This method handles updates to:

• Leaves: Inserts new or updated leaves, removes specified leaves.
• Subtrees: Inserts new or updated subtrees, removes specified subtrees.
• Root hash: Sets the new root hash of the SMT.

All operations are performed after acquiring write locks on the root, leaves, and subtrees collections, ensuring atomicity of the batch update.

Errors

Returns StorageError::Backend if any of the necessary write locks (for root, leaves, or subtrees) cannot be acquired.

fn iter_leaves( &self, ) -> Result<Box<dyn Iterator<Item = (u64, SmtLeaf)> + '_>, StorageError>

Returns an iterator over all (index, SmtLeaf) pairs in the storage.

The iterator provides access to the current state of the leaves.

Errors

Returns StorageError::Backend if the read lock for leaves cannot be acquired.

fn iter_subtrees( &self, ) -> Result<Box<dyn Iterator<Item = Subtree> + '_>, StorageError>

Returns an iterator over all Subtrees in the storage.

The iterator provides access to the current subtrees from storage.

Errors

Returns StorageError::Backend if the read lock for subtrees cannot be acquired.

fn get_depth24(&self) -> Result<Vec<(u64, Word)>, StorageError>

Retrieves all depth 24 roots for fast tree rebuilding.

For MemoryStorage, this returns an empty vector since all data is already in memory and there’s no startup performance benefit to caching depth 24 roots.