Struct AccountTree 

pub struct AccountTree<S = Smt> { /* private fields */ }

The sparse merkle tree of all accounts in the blockchain.

The key is the AccountId while the value is the current state commitment of the account, i.e. Account::commitment. If the account is new, then the commitment is the EMPTY_WORD.

Each account ID occupies exactly one leaf in the tree, which is identified by its AccountId::prefix. In other words, account ID prefixes are unique in the blockchain.

Implementations

impl<S> AccountTree<S>

where S: AccountTreeBackend<Error = MerkleError>,

pub const DEPTH: u8 = 64u8

The depth of the account tree.

pub fn new(smt: S) -> Result<Self, AccountTreeError>

Creates a new AccountTree from its inner representation with validation.

This constructor validates that the provided SMT upholds the guarantees of the AccountTree. The constructor ensures only the uniqueness of the account ID prefix.

Errors

Returns an error if:

• The SMT contains duplicate account ID prefixes

pub fn new_unchecked(smt: S) -> Self

Creates a new AccountTree from its inner representation without validation.

Warning

Assumes the provided SMT upholds the guarantees of the AccountTree. Specifically:

• Each account ID prefix must be unique (no duplicate prefixes allowed)
• The SMT should only contain valid account IDs and their state commitments

See type-level documentation for more details on these invariants. Using this constructor with an SMT that violates these guarantees may lead to undefined behavior.

pub fn open(&self, account_id: AccountId) -> AccountWitness

Returns an opening of the leaf associated with the account_id. This is a proof of the current state commitment of the given account ID.

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

Panics

Panics if the SMT backend fails to open the leaf (only possible with LargeSmt backend).

pub fn get(&self, account_id: AccountId) -> Word

Returns the current state commitment of the given account ID.

pub fn root(&self) -> Word

Returns the root of the tree.

pub fn contains_account_id_prefix( &self, account_id_prefix: AccountIdPrefix, ) -> bool

Returns true if the tree contains a leaf for the given account ID prefix.

pub fn num_accounts(&self) -> usize

Returns the number of account IDs in this tree.

pub fn account_commitments(&self) -> impl Iterator<Item = (AccountId, Word)>

Returns an iterator over the account ID state commitment pairs in the tree.

pub fn compute_mutations( &self, account_commitments: impl IntoIterator<Item = (AccountId, Word)>, ) -> Result<AccountMutationSet, AccountTreeError>

Computes the necessary changes to insert the specified (account ID, state commitment) pairs into this tree, allowing for validation before applying those changes.

Self::apply_mutations can be used in order to commit these changes to the tree.

If the concurrent feature of miden-crypto is enabled, this function uses a parallel implementation to compute the mutations, otherwise it defaults to the sequential implementation.

This is a thin wrapper around Smt::compute_mutations. See its documentation for more details.

Errors

Returns an error if:

• an insertion of an account ID would violate the uniqueness of account ID prefixes in the tree.

pub fn insert( &mut self, account_id: AccountId, state_commitment: Word, ) -> Result<Word, AccountTreeError>

Inserts the state commitment for the given account ID, returning the previous state commitment associated with that ID.

This also recomputes all hashes between the leaf (associated with the key) and the root, updating the root itself.

Errors

Returns an error if:

• the prefix of the account ID already exists in the tree.

pub fn apply_mutations( &mut self, mutations: AccountMutationSet, ) -> Result<(), AccountTreeError>

Applies the prospective mutations computed with Self::compute_mutations to this tree.

Errors

Returns an error if:

• mutations was computed on a tree with a different root than this one.

pub fn apply_mutations_with_reversion( &mut self, mutations: AccountMutationSet, ) -> Result<AccountMutationSet, AccountTreeError>

Applies the prospective mutations computed with Self::compute_mutations to this tree and returns the reverse mutation set.

Applying the reverse mutation sets to the updated tree will revert the changes.

Errors

Returns an error if:

• mutations was computed on a tree with a different root than this one.

impl AccountTree<Smt>

pub fn with_entries<I>( entries: impl IntoIterator<Item = (AccountId, Word), IntoIter = I>, ) -> Result<Self, AccountTreeError>

where I: ExactSizeIterator<Item = (AccountId, Word)>,

Creates a new AccountTree with the provided entries.

This is a convenience method for testing that creates an SMT backend with the provided entries and wraps it in an AccountTree. It validates that the entries don’t contain duplicate prefixes.

Errors

Returns an error if:

• The provided entries contain duplicate account ID prefixes
• The backend fails to create the SMT with the entries

Trait Implementations

impl<S: Clone> Clone for AccountTree<S>

fn clone(&self) -> AccountTree<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for AccountTree<S>

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

Formats the value using the given formatter.

impl<S> Default for AccountTree<S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl Deserializable for AccountTree

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 read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

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

impl<S: PartialEq> PartialEq for AccountTree<S>

fn eq(&self, other: &AccountTree<S>) -> 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 AccountTree

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<S: Eq> Eq for AccountTree<S>

impl<S> StructuralPartialEq for AccountTree<S>