Struct SparseLedgerImpl

pub(super) struct SparseLedgerImpl<K: Eq + Hash, V> {
    pub values: BTreeMap<AccountIndex, V>,
    pub indexes: HashMap<K, Address>,
    pub indexes_list: VecDeque<K>,
    pub hashes_matrix: HashesMatrix,
    pub depth: usize,
}

Fields

values: BTreeMap<AccountIndex, V>

indexes: HashMap<K, Address>

indexes_list: VecDeque<K>

Mirror OCaml, where the index is ordered, and can have duplicates

hashes_matrix: HashesMatrix

depth: usize

Implementations

impl SparseLedgerImpl<AccountId, Account>

pub fn create(depth: usize, root_hash: Fp) -> Self

pub fn of_ledger_subset_exn(oledger: Mask, keys: &[AccountId]) -> Self

fn get_or_initialize_exn( &self, account_id: &AccountId, addr: &Address, ) -> (AccountState, Account)

pub fn has_locked_tokens_exn( &self, global_slot: Slot, account_id: AccountId, ) -> bool

pub fn iteri<F>(&self, fun: F)

where F: Fn(Address, &Account),

pub fn add_path( &mut self, merkle_path: &[MerklePath], account_id: AccountId, account: Account, )

pub(super) fn get_index(&self, account_id: &AccountId) -> Option<&Address>

fn get(&self, addr: &Address) -> Option<&Account>

pub fn get_exn(&self, addr: &Address) -> &Account

pub fn set_exn(&mut self, addr: Address, value: Box<Account>)

pub fn find_index_exn(&self, key: AccountId) -> Address

pub fn path_exn(&mut self, addr: Address) -> Vec<MerklePath>

fn get_value_hash(&mut self, addr: Address) -> Fp

fn get_node_hash(&mut self, addr: &Address, left: Fp, right: Fp) -> Fp

fn emulate_tree_to_get_path( &mut self, addr: Address, path: &mut AddressIterator, merkle_path: &mut Vec<MerklePath>, ) -> Fp

pub fn merkle_root(&mut self) -> Fp

pub fn emulate_tree_merkle_root(&mut self, addr: Address) -> Fp

fn location_of_account_impl(&self, account_id: &AccountId) -> Option<Address>

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for SparseLedgerImpl<K, V>

fn clone(&self) -> SparseLedgerImpl<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + Hash, V: Debug> Debug for SparseLedgerImpl<K, V>

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

Formats the value using the given formatter.

impl LedgerIntf for SparseLedgerImpl<AccountId, Account>

fn get(&self, addr: &Self::Location) -> Option<Box<Account>>

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L58

fn location_of_account(&self, account_id: &AccountId) -> Option<Self::Location>

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L66

fn set(&mut self, addr: &Self::Location, account: Box<Account>)

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L75

fn get_or_create( &mut self, account_id: &AccountId, ) -> Result<(AccountState, Box<Account>, Self::Location), String>

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L96

fn create_new_account( &mut self, account_id: AccountId, to_set: Account, ) -> Result<(), ()>

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L109

fn remove_accounts_exn(&mut self, _account_ids: &[AccountId])

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L112

fn merkle_root(&mut self) -> Fp

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L115

fn empty(depth: usize) -> Self

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_base/sparse_ledger_base.ml#L142

type Location = Address<NBYTES>

fn create_masked(&self) -> Self

fn apply_mask(&mut self, _mask: Self)

fn account_locations(&self) -> Vec<Self::Location>

Returns all account locations in this ledger (and its parents if any)

impl<K: PartialEq + Eq + Hash, V: PartialEq> PartialEq for SparseLedgerImpl<K, V>

fn eq(&self, other: &SparseLedgerImpl<K, V>) -> 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<K: Eq + Hash, V> StructuralPartialEq for SparseLedgerImpl<K, V>