Struct ethcore::state_db::StateDB

pub struct StateDB { /* private fields */ }

State database abstraction. Manages shared global state cache which reflects the canonical state as it is on the disk. All the entries in the cache are clean. A clone of StateDB may be created as canonical or not. For canonical clones local cache is accumulated and applied in sync_cache For non-canonical clones local cache is dropped.

Global cache propagation. After a State object has been committed to the trie it propagates its local cache into the StateDB local cache using add_to_account_cache function. Then, after the block has been added to the chain the local cache in the StateDB is propagated into the global cache.

Implementations

impl StateDB

pub fn new(db: Box<dyn JournalDB>, cache_size: usize) -> StateDB

Create a new instance wrapping JournalDB and the maximum allowed size of the LRU cache in bytes. Actual used memory may (read: will) be higher due to bookkeeping.

pub fn journal_under(
    &mut self,
    batch: &mut DBTransaction,
    now: u64,
    id: &H256
) -> Result<u32>

Journal all recent operations under the given era and ID.

pub fn mark_canonical(
    &mut self,
    batch: &mut DBTransaction,
    end_era: u64,
    canon_id: &H256
) -> Result<u32>

Mark a given candidate from an ancient era as canonical, enacting its removals from the backing database and reverting any non-canonical historical commit’s insertions.

pub fn sync_cache(
    &mut self,
    enacted: &[H256],
    retracted: &[H256],
    is_best: bool
)

the global cache with the best block state. This function updates the global cache by removing entries that are invalidated by chain reorganization. sync_cache should be called after the block has been committed and the blockchain route has ben calculated.

pub fn as_hash_db(&self) -> &dyn HashDB<KeccakHasher, DBValue>

Conversion method to interpret self as HashDB reference

pub fn as_hash_db_mut(&mut self) -> &mut dyn HashDB<KeccakHasher, DBValue>

Conversion method to interpret self as mutable HashDB reference

pub fn boxed_clone(&self) -> StateDB

Clone the database.

pub fn boxed_clone_canon(&self, parent: &H256) -> StateDB

Clone the database for a canonical state.

pub fn is_pruned(&self) -> bool

Check if pruning is enabled on the database.

pub fn get_sizes(&self, sizes: &mut BTreeMap<String, usize>)

Heap size used.

pub fn journal_db(&self) -> &dyn JournalDB

Returns underlying JournalDB.

pub fn cache_size(&self) -> usize

Query how much memory is set aside for the accounts cache (in bytes).

Trait Implementations

impl Backend for StateDB

fn as_hash_db(&self) -> &dyn HashDB<KeccakHasher, DBValue>

Treat the backend as a read-only hashdb.

fn as_hash_db_mut(&mut self) -> &mut dyn HashDB<KeccakHasher, DBValue>

Treat the backend as a writeable hashdb.

fn add_to_account_cache(
    &mut self,
    addr: Address,
    data: Option<Account>,
    modified: bool
)

t_nb 9.4 Add an account entry to the cache.

fn cache_code(&self, hash: H256, code: Arc<Vec<u8>>)

Add a global code cache entry. This doesn’t need to worry about canonicality because it simply maps hashes to raw code and will always be correct in the absence of hash collisions.

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

Get basic copy of the cached account. Not required to include storage. Returns ‘None’ if cache is disabled or if the account is not cached.

fn get_cached<F, U>(&self, a: &Address, f: F) -> Option<U> where
    F: FnOnce(Option<&mut Account>) -> U, 

Get value from a cached account. None is passed to the closure if the account entry cached is known not to exist. None is returned if the entry is not cached.

fn get_cached_code(&self, hash: &H256) -> Option<Arc<Vec<u8>>>

Get cached code based on hash.