Struct Mask

pub struct Mask {
    pub inner: Arc<Mutex<MaskImpl>>,
}

Fields

inner: Arc<Mutex<MaskImpl>>

Implementations

impl Mask

pub(super) fn with<F, R>(&self, fun: F) -> R

where F: FnOnce(&mut MaskImpl) -> R,

impl Mask

pub fn new_root(db: Database<V2>) -> Self

pub fn new_unattached(depth: usize) -> Self

pub fn create(depth: usize) -> Self

pub fn create_with_token_owners(depth: usize) -> Self

pub fn set_token_owners(&mut self)

pub fn unset_token_owners(&mut self)

pub fn make_child(&self) -> Mask

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

pub(crate) fn nmasks_to_root(&self) -> usize

pub fn copy(&self) -> Mask

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

Make mask a child of self

pub fn unregister_mask(&self, behavior: UnregisterBehavior) -> Mask

Detach this mask from its parent

pub(super) fn unregister_mask_impl( &self, behavior: UnregisterBehavior, remove_from_parent: bool, ) -> Mask

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

pub fn is_root(&self) -> bool

pub fn is_attached(&self) -> bool

fn uuid(&self) -> Uuid

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

pub fn unset_parent(&self, trigger_detach_signal: bool)

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

// o // / // / // o — o - // ^ ^
// parent |
// mask o // children

Removes the attached mask from its parent and attaches the children to the parent instead. Raises an exception if the merkle roots of the mask and the parent are not the same.

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

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

pub fn commit(&self)

commit all state to the parent, flush state locally

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(&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(&self) -> Option<Mask>

pub fn depth(&self) -> u8

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

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

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

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

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

pub fn short(&self) -> MaskImplShort

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

Validate inner hashes by rehashing everything. Returns Ok(()) if recalculated hashes matched the existing ones.

Warning: Heavy operation.

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

Returns a vector of tuples of (index, hash) of all the hashes contained in this mask.

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

Sets the contents of this mask’s hash matrix using raw data.

pub fn has_token_owners(&self) -> bool

pub fn fuzzing_to_root(&self) -> Mask

Use for fuzzing only

Trait Implementations

impl BaseLedger for Mask

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 Mask

fn clone(&self) -> Mask

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mask

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

Formats the value using the given formatter.

impl Drop for Mask

fn drop(&mut self)

Executes the destructor for this type.

impl LedgerInterface for Mask

type W = ()

type AccountUpdate = AccountUpdateSkeleton<Body>

type Account = Account

type Bool = bool

type InclusionProof = ExistingOrNew<<Mask as LedgerIntf>::Location>

fn empty(depth: usize) -> Self

fn get_account( &self, account_update: &Self::AccountUpdate, _w: &mut Self::W, ) -> Result<(Self::Account, Self::InclusionProof), String>

fn set_account( &mut self, account: (Self::Account, Self::InclusionProof), _w: &mut Self::W, ) -> Result<(), String>

fn check_inclusion( &self, _account: &(Self::Account, Self::InclusionProof), _w: &mut Self::W, )

fn check_account( public_key: &CompressedPubKey, token_id: &TokenId, account: (&Self::Account, &Self::InclusionProof), _w: &mut Self::W, ) -> Result<Self::Bool, String>

fn exists_no_check(self, _w: &mut Self::W) -> Self

fn exists_no_check_on_bool(self, _b: Self::Bool, _w: &mut Self::W) -> Self

impl LedgerIntf for Mask

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

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_ledger/ledger.ml#L311

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

https://github.com/MinaProtocol/mina/blob/05c2f73d0f6e4f1341286843814ce02dcb3919e0/src/lib/mina_ledger/ledger.ml#L304

fn create_masked(&self) -> Self

Create a ledger as a mask on top of the existing ledger. Warning: This skips mask registration, for use in transaction logic, where we always have either 0 or 1 masks, and the mask is always either committed or discarded. This function is deliberately not exposed in the public API of this module. This should NOT be used to create a ledger for other purposes.

type Location = Address<NBYTES>

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

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

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

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

fn merkle_root(&mut self) -> Fp

fn empty(depth: usize) -> 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)