Struct DatabaseImpl

pub struct DatabaseImpl<T: TreeVersion> {
    accounts: Vec<Option<T::Account>>,
    pub hashes_matrix: HashesMatrix,
    id_to_addr: HashMap<AccountId, Address>,
    token_owners: Option<HashMap<T::TokenId, AccountId>>,
    depth: u8,
    last_location: Option<Address>,
    naccounts: usize,
    uuid: Uuid,
    directory: PathBuf,
}

Fields

accounts: Vec<Option<T::Account>>

hashes_matrix: HashesMatrix

id_to_addr: HashMap<AccountId, Address>

token_owners: Option<HashMap<T::TokenId, AccountId>>

depth: u8

last_location: Option<Address>

naccounts: usize

uuid: Uuid

directory: PathBuf

Implementations

impl DatabaseImpl<V2>

pub fn clone_db(&self, new_directory: PathBuf) -> Self

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

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

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

where F: FnMut(Address, &Account),

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

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

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

pub fn create_checkpoint(&self, directory_name: String)

pub fn make_checkpoint(&self, directory_name: String)

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

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

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

pub fn invalidate_hashes(&mut self, account_index: AccountIndex)

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

pub fn has_token_owners(&self) -> bool

impl DatabaseImpl<V1>

pub fn create_account( &mut self, _account_id: (), account: AccountLegacy, ) -> Result<Address, DatabaseError>

impl DatabaseImpl<V2>

const NACCOUNTS: usize = 10_000usize

const NTOKENS: usize = 10usize

pub fn create_with_dir(depth: u8, dir_name: Option<PathBuf>) -> Self

pub fn create(depth: u8) -> Self

pub fn create_with_token_owners(depth: u8) -> Self

pub fn set_token_owners(&mut self)

pub fn unset_token_owners(&mut self)

pub fn root_hash(&mut self) -> Fp

pub fn naccounts(&self) -> usize

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

Trait Implementations

impl BaseLedger for DatabaseImpl<V2>

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<T: Clone + TreeVersion> Clone for DatabaseImpl<T>

where T::Account: Clone, T::TokenId: Clone,

fn clone(&self) -> DatabaseImpl<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: TreeVersion> Debug for DatabaseImpl<T>

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

Formats the value using the given formatter.