Struct StorageMap

pub struct StorageMap { /* private fields */ }

An account storage map is a sparse merkle tree of depth Self::TREE_DEPTH (64).

It can be used to store a large amount of data in an account than would be otherwise possible using just the account’s storage slots. This works by storing the root of the map’s underlying SMT in one account storage slot. Each map entry is a leaf in the tree and its inclusion is proven while retrieving it (e.g. via account::get_map_item).

As a side-effect, this also means that not all entries of the map have to be present at transaction execution time in order to access or modify the map. It is sufficient if just the accessed/modified items are present in the advice provider.

Because the keys of the map are user-chosen and thus not necessarily uniformly distributed, the tree could be imbalanced and made less efficient. To mitigate that, the keys used in the storage map are hashed before they are inserted into the SMT, which creates a uniform distribution. The original keys are retained in a separate map. This causes redundancy but allows for introspection of the map, e.g. by querying the set of stored (original) keys which is useful in debugging and explorer scenarios.

Implementations

impl StorageMap

pub const TREE_DEPTH: u8 = 64u8

Depth of the storage tree.

pub const EMPTY_VALUE: [BaseElement; 4] = Smt::EMPTY_VALUE

The default value of empty leaves.

pub fn new() -> StorageMap

Returns a new StorageMap.

All leaves in the returned tree are set to Self::EMPTY_VALUE.

pub fn with_entries<I>( entries: impl IntoIterator<Item = (RpoDigest, [BaseElement; 4]), IntoIter = I>, ) -> Result<StorageMap, StorageMapError>

where I: ExactSizeIterator<Item = (RpoDigest, [BaseElement; 4])>,

Creates a new StorageMap from the provided key-value entries.

Errors

Returns an error if:

• the provided entries contain multiple values for the same key.

pub fn root(&self) -> RpoDigest

Returns the root of the underlying sparse merkle tree.

pub fn get(&self, key: &RpoDigest) -> [BaseElement; 4]

Returns the value corresponding to the key or Self::EMPTY_VALUE if the key is not associated with a value.

pub fn open(&self, key: &RpoDigest) -> SmtProof

Returns an opening of the leaf associated with key.

Conceptually, an opening is a Merkle path to the leaf, as well as the leaf itself.

pub fn leaves( &self, ) -> impl Iterator<Item = (LeafIndex<miden_objects::::account::storage::map::{impl#0}::leaves::{constant#0}>, &SmtLeaf)>

Returns an iterator over the leaves of the underlying Smt.

pub fn entries(&self) -> impl Iterator<Item = (&RpoDigest, &[BaseElement; 4])>

Returns an iterator over the key value pairs of the map.

pub fn inner_nodes(&self) -> impl Iterator<Item = InnerNodeInfo>

Returns an iterator over the inner nodes of the underlying Smt.

pub fn insert( &mut self, key: RpoDigest, value: [BaseElement; 4], ) -> [BaseElement; 4]

Inserts or updates the given key value pair and returns the previous value, or Self::EMPTY_VALUE if no entry was previously present.

If the provided value is Self::EMPTY_VALUE the entry will be removed.

pub fn apply_delta(&mut self, delta: &StorageMapDelta) -> RpoDigest

Applies the provided delta to this account storage.

pub fn into_entries(self) -> BTreeMap<RpoDigest, [BaseElement; 4]>

Consumes the map and returns the underlying map of entries.

pub fn hash_key(key: RpoDigest) -> RpoDigest

Hashes the given key to get the key of the SMT.

Trait Implementations

impl Clone for StorageMap

fn clone(&self) -> StorageMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StorageMap

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

Formats the value using the given formatter.

impl Default for StorageMap

fn default() -> StorageMap

Returns the “default value” for a type.

impl Deserializable for StorageMap

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

where R: ByteReader,

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

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

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

impl PartialEq for StorageMap

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

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

const 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 StorageMap

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

where W: ByteWriter,

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

fn get_size_hint(&self) -> usize

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

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

Serializes self into a vector of bytes.

impl Eq for StorageMap

impl StructuralPartialEq for StorageMap