Enum MaskImpl

pub enum MaskImpl {
    Root {
        database: Database<V2>,
        childs: HashMap<Uuid, Mask>,
    },
    Attached {
        parent: Mask,
        owning_account: HashMap<AccountIndex, Account>,
        token_owners: Option<HashMap<TokenId, AccountId>>,
        id_to_addr: HashMap<AccountId, Address>,
        last_location: Option<Address>,
        depth: u8,
        childs: HashMap<Uuid, Mask>,
        hashes: HashesMatrix,
        uuid: Uuid,
    },
    Unattached {
        depth: u8,
        childs: HashMap<Uuid, Mask>,
        owning_account: HashMap<AccountIndex, Account>,
        token_owners: Option<HashMap<TokenId, AccountId>>,
        id_to_addr: HashMap<AccountId, Address>,
        last_location: Option<Address>,
        hashes: HashesMatrix,
        uuid: Uuid,
    },
}

Variants

Root

Fields

database: Database<V2>

childs: HashMap<Uuid, Mask>

Attached

Fields

parent: Mask

owning_account: HashMap<AccountIndex, Account>

token_owners: Option<HashMap<TokenId, AccountId>>

id_to_addr: HashMap<AccountId, Address>

last_location: Option<Address>

depth: u8

childs: HashMap<Uuid, Mask>

hashes: HashesMatrix

uuid: Uuid

Unattached

Fields

depth: u8

childs: HashMap<Uuid, Mask>

owning_account: HashMap<AccountIndex, Account>

token_owners: Option<HashMap<TokenId, AccountId>>

id_to_addr: HashMap<AccountId, Address>

last_location: Option<Address>

hashes: HashesMatrix

uuid: Uuid

Implementations

impl MaskImpl

pub fn short(&self) -> MaskImplShort

For debug purpose only

pub fn is_root(&self) -> bool

pub fn is_attached(&self) -> bool

pub(super) fn any_child_alive(&self) -> bool

pub fn set_token_owners(&mut self)

pub fn unset_token_owners(&mut self)

pub fn has_token_owners(&self) -> bool

pub fn register_mask(&mut self, self_mask: Mask, mask: Mask) -> Mask

Make mask a child of self

pub fn unregister_mask( &mut self, behavior: UnregisterBehavior, remove_from_parent: bool, )

Detach this mask from its parent

pub fn remove_and_reparent(&mut self) -> Option<Mask>

pub fn set_parent( &mut self, parent: Mask, parent_last_filled: Option<Option<Address>>, )

fn uuid(&self) -> Uuid

pub fn get_parent(&self) -> Option<Mask>

pub fn unset_parent(&mut self, trigger_detach_signal: bool)

pub fn nmasks_to_root(&self) -> usize

pub fn get_hash(&mut self, addr: Address) -> Option<Fp>

get hash from mask, if present, else from its parent

pub fn commit(&mut self)

commit all state to the parent, flush state locally

pub fn commit_and_reparent(&mut self) -> Option<Mask>

pub fn commit_and_reparent_to_root(&mut self) -> Option<Mask>

commit all the masks from this mask all the way upto the root and return root mask while also detaching all intermediary masks.

pub fn parent_set_notify( &mut self, account_index: AccountIndex, account: &Account, )

called when parent sets an account; update local state

if the mask’s parent sets an account, we can prune an entry in the mask if the account in the parent is the same in the mask *)

pub fn remove_parent(&mut self) -> Option<Mask>

pub fn remove_child_uuid(&mut self, uuid: Uuid) -> Option<Mask>

fn childs(&mut self) -> &mut HashMap<Uuid, Mask>

pub fn get_cached_hash(&self, addr: &Address) -> Option<Fp>

pub fn set_cached_hash_unchecked(&mut self, addr: &Address, hash: Fp)

fn set_cached_hash(&mut self, addr: &Address, hash: Fp)

pub fn empty_hash_at_height(&mut self, height: usize) -> Fp

fn invalidate_hashes(&mut self, account_index: AccountIndex)

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

pub fn compute_hash_or_parent_for_merkle_path( &mut self, addr: Address, last_account: &Address, path: &mut AddressIterator, merkle_path: &mut Vec<MerklePath>, first: bool, ) -> Fp

pub fn depth(&self) -> u8

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

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

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

fn remove_own_account(&mut self, ids: &[AccountId])

pub(super) fn set_impl( &mut self, addr: Address, account: Box<Account>, child_to_ignore: Option<Uuid>, )

pub(super) fn transfert_hashes(&mut self, new_hashes: HashesMatrix)

pub(super) fn remove_accounts_without_notif(&mut self, ids: &[AccountId])

fn recurse_on_childs<F>(&mut self, fun: &mut F)

where F: FnMut(&mut MaskImpl),

pub fn validate_inner_hashes(&mut self) -> Result<(), ()>

pub fn get_raw_inner_hashes(&self) -> Vec<(u64, Fp)>

pub fn set_raw_inner_hashes(&self, raw_hashes: Vec<(u64, Fp)>)

Trait Implementations

impl BaseLedger for MaskImpl

fn to_list(&self) -> Vec<Account>

list of accounts in the ledger

fn iter<F>(&self, fun: F)

where F: FnMut(&Account),

iterate over all indexes and accounts

fn fold<B, F>(&self, init: B, fun: F) -> B

where F: FnMut(B, &Account) -> B,

fold over accounts in the ledger, passing the Merkle address

fn fold_with_ignored_accounts<B, F>( &self, ignoreds: HashSet<AccountId>, init: B, fun: F, ) -> B

where F: FnMut(B, &Account) -> B,

the set of account_ids are ledger elements to skip during the fold, because they’re in a mask

fn fold_until<B, F>(&self, init: B, fun: F) -> B

where F: FnMut(B, &Account) -> ControlFlow<B, B>,

fold until fun returns ControlFlow::Stop

fn accounts(&self) -> HashSet<AccountId>

set of account ids associated with accounts

fn token_owner(&self, token_id: TokenId) -> Option<AccountId>

Get the account id that owns a token.

fn tokens(&self, public_key: CompressedPubKey) -> HashSet<TokenId>

Get all of the tokens for which a public key has accounts.

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

fn location_of_account_batch( &self, account_ids: &[AccountId], ) -> Vec<(AccountId, Option<Address>)>

fn get_or_create_account( &mut self, account_id: AccountId, account: Account, ) -> Result<GetOrCreated, DatabaseError>

This may return an error if the ledger is full.

fn close(&self)

the ledger should not be used after calling close

fn last_filled(&self) -> Option<Address>

for account locations in the ledger, the last (rightmost) filled location

fn get_uuid(&self) -> Uuid

fn get_directory(&self) -> Option<PathBuf>

return Some directory for ledgers that use a file system, else None

fn get_account_hash(&mut self, account_index: AccountIndex) -> Option<Fp>

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

fn get_batch(&self, addr: &[Address]) -> Vec<(Address, Option<Box<Account>>)>

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

fn set_batch(&mut self, list: &[(Address, Box<Account>)])

fn get_at_index(&self, index: AccountIndex) -> Option<Box<Account>>

fn set_at_index( &mut self, index: AccountIndex, account: Box<Account>, ) -> Result<(), ()>

fn index_of_account(&self, account_id: AccountId) -> Option<AccountIndex>

fn merkle_root(&mut self) -> Fp

meant to be a fast operation: the root hash is stored, rather than calculated dynamically

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

fn merkle_path_at_index(&mut self, index: AccountIndex) -> Vec<MerklePath>

fn remove_accounts(&mut self, ids: &[AccountId])

fn detached_signal(&mut self)

Triggers when the ledger has been detached and should no longer be accessed.

fn depth(&self) -> u8

fn num_accounts(&self) -> usize

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

fn get_inner_hash_at_addr(&mut self, addr: Address) -> Result<Fp, String>

fn set_inner_hash_at_addr( &mut self, _addr: Address, _hash: Fp, ) -> Result<(), ()>

fn set_all_accounts_rooted_at( &mut self, addr: Address, accounts: &[Box<Account>], ) -> Result<(), ()>

fn get_all_accounts_rooted_at( &self, addr: Address, ) -> Option<Vec<(Address, Box<Account>)>>

Get all of the accounts that are in a subtree of the underlying Merkle tree rooted at address. The accounts are ordered by their addresses.

fn make_space_for(&mut self, _space: usize)

fn commit(&mut self)

Used on mask only, has no effect with other implementation Required for LedgerIntf on masks

fn set_batch_accounts(&mut self, list: &[(Address, Box<Account>)])

impl Clone for MaskImpl

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MaskImpl

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

Formats the value using the given formatter.

impl Drop for MaskImpl

fn drop(&mut self)

Executes the destructor for this type.