Trait sp_state_machine::backend::Backend[−][src]

pub trait Backend<H: Hasher>: Debug {
    type Error: Error;
    type Transaction: Consolidate + Default + Send;
    type TrieBackendStorage: TrieBackendStorage<H>;

Show methods    fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>, Self::Error>;

    fn child_storage(
        &self, 
        child_info: &ChildInfo, 
        key: &[u8]
    ) -> Result<Option<StorageValue>, Self::Error>;

    fn next_storage_key(
        &self, 
        key: &[u8]
    ) -> Result<Option<StorageKey>, Self::Error>;

    fn next_child_storage_key(
        &self, 
        child_info: &ChildInfo, 
        key: &[u8]
    ) -> Result<Option<StorageKey>, Self::Error>;

    fn apply_to_key_values_while<F: FnMut(Vec<u8>, Vec<u8>) -> bool>(
        &self, 
        child_info: Option<&ChildInfo>, 
        prefix: Option<&[u8]>, 
        start_at: Option<&[u8]>, 
        f: F, 
        allow_missing: bool
    ) -> Result<bool, Self::Error>;

    fn apply_to_keys_while<F: FnMut(&[u8]) -> bool>(
        &self, 
        child_info: Option<&ChildInfo>, 
        prefix: Option<&[u8]>, 
        f: F
    );

    fn for_key_values_with_prefix<F: FnMut(&[u8], &[u8])>(
        &self, 
        prefix: &[u8], 
        f: F
    );

    fn for_child_keys_with_prefix<F: FnMut(&[u8])>(
        &self, 
        child_info: &ChildInfo, 
        prefix: &[u8], 
        f: F
    );

    fn storage_root<'a>(
        &self, 
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>
    ) -> (H::Out, Self::Transaction)
    where
        H::Out: Ord;

    fn child_storage_root<'a>(
        &self, 
        child_info: &ChildInfo, 
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>
    ) -> (H::Out, bool, Self::Transaction)
    where
        H::Out: Ord;

    fn pairs(&self) -> Vec<(StorageKey, StorageValue)>;

    fn register_overlay_stats(&self, _stats: &StateMachineStats);

    fn usage_info(&self) -> UsageInfo;

    fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>, Self::Error> { ... }

    fn child_storage_hash(
        &self, 
        child_info: &ChildInfo, 
        key: &[u8]
    ) -> Result<Option<H::Out>, Self::Error> { ... }

    fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> { ... }

    fn exists_child_storage(
        &self, 
        child_info: &ChildInfo, 
        key: &[u8]
    ) -> Result<bool, Self::Error> { ... }

    fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) { ... }

    fn keys(&self, prefix: &[u8]) -> Vec<StorageKey> { ... }

    fn child_keys(
        &self, 
        child_info: &ChildInfo, 
        prefix: &[u8]
    ) -> Vec<StorageKey> { ... }

    fn as_trie_backend(
        &mut self
    ) -> Option<&TrieBackend<Self::TrieBackendStorage, H>> { ... }

    fn full_storage_root<'a>(
        &self, 
        delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>, 
        child_deltas: impl Iterator<Item = (&'a ChildInfo, impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>)>
    ) -> (H::Out, Self::Transaction)
    where
        H::Out: Ord + Encode,
    { ... }

    fn wipe(&self) -> Result<(), Self::Error> { ... }

    fn commit(
        &self, 
        _: H::Out, 
        _: Self::Transaction, 
        _: StorageCollection, 
        _: ChildStorageCollection
    ) -> Result<(), Self::Error> { ... }

    fn read_write_count(&self) -> (u32, u32, u32, u32) { ... }

    fn reset_read_write_count(&self) { ... }

    fn get_whitelist(&self) -> Vec<TrackedStorageKey> { ... }

    fn set_whitelist(&self, _: Vec<TrackedStorageKey>) { ... }

    fn proof_size(&self) -> Option<u32> { ... }

    fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> { ... }

}
Expand description

A state backend is used to read state data and can have changes committed to it.

The clone operation (if implemented) should be cheap.

Associated Types

An error type when fetching data is not possible.

Storage changes to be applied if committing

Type of trie backend storage.

Required methods

Get keyed storage or None if there is nothing associated.

Get keyed child storage or None if there is nothing associated.

Return the next key in storage in lexicographic order or None if there is no value.

Return the next key in child storage in lexicographic order or None if there is no value.

Iterate over storage starting at key, for a given prefix and child trie. Aborts as soon as f returns false. Warning, this fails at first error when usual iteration skips errors. If allow_missing is true, iteration stops when it reaches a missing trie node. Otherwise an error is produced.

Returns true if trie end is reached.

Retrieve all entries keys of storage and call f for each of those keys. Aborts as soon as f returns false.

Retrieve all entries keys and values of which start with the given prefix and call f for each of those keys.

Retrieve all child entries keys which start with the given prefix and call f for each of those keys.

Calculate the storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. Does not include child storage updates.

Calculate the child storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. The second argument is true if child storage root equals default storage root.

Get all key/value pairs into a Vec.

Register stats from overlay of state machine.

By default nothing is registered.

Query backend usage statistics (i/o, memory)

Not all implementations are expected to be able to do this. In the case when they don’t, empty statistics is returned.

Provided methods

Get keyed storage value hash or None if there is nothing associated.

Get child keyed storage value hash or None if there is nothing associated.

true if a key exists in storage.

true if a key exists in child storage.

Retrieve all entries keys which start with the given prefix and call f for each of those keys.

Get all keys with given prefix

Get all keys of child storage with given prefix

Try convert into trie backend.

Calculate the storage root, with given delta over what is already stored in the backend, and produce a “transaction” that can be used to commit. Does include child storage updates.

Wipe the state database.

Commit given transaction to storage.

Get the read/write count of the db

Get the read/write count of the db

Get the whitelist for tracking db reads/writes

Update the whitelist for tracking db reads/writes

Estimate proof size

Extend storage info for benchmarking db

Implementors