Struct RevertibleStore 

pub struct RevertibleStore<S> { /* private fields */ }

👎Deprecating in a future version: RevertibleStore has a bug where using the operation log to revert changes does not guarantee deterministic Merkle root hashes. Use InMemoryStore which implements a correct rollback procedure.

A wrapper store that implements rudimentary apply()/reset() support for other stores.

RevertibleStore relies on maintaining a list of processed operations - delete and set.

If it has to revert a failed transaction, it reverts the previous operations as so:

• If reverting an overwriting set or delete operation, it performs a set with the old value.
• If reverting a non-overwriting set, it deletes the current value.

Note that this scheme makes it trickier to maintain deterministic Merkle root hashes: an overwriting set doesn’t reorganize a Merkle tree - but non-overwriting set and delete operations may reorganize a Merkle tree - which may change the root hash. However, a Merkle store should have no effect on a failed transaction.

Implementations

impl<S> RevertibleStore<S>

where S: Store,

pub fn new(store: S) -> Self

Trait Implementations

impl<S: Clone> Clone for RevertibleStore<S>

fn clone(&self) -> RevertibleStore<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for RevertibleStore<S>

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

Formats the value using the given formatter.

impl<S> Default for RevertibleStore<S>

where S: Default + Store,

fn default() -> Self

Returns the “default value” for a type.

impl<S> ProvableStore for RevertibleStore<S>

where S: ProvableStore,

fn root_hash(&self) -> Vec<u8>

Return a vector commitment

fn get_proof(&self, height: Height, key: &Path) -> Option<CommitmentProof>

Return proof of existence for key

impl<S> Store for RevertibleStore<S>

where S: Store,

fn reset(&mut self)

Revert all operations in the operation log.

This method doesn’t guarantee that the Merkle tree will be reverted to the correct previous root hash. It should be avoided. Use InMemoryStore directly which implements a correct rollback procedure.

GH issue: informalsystems/basecoin-rs#129

type Error = <S as Store>::Error

Error type - expected to envelope all possible errors in store

fn set( &mut self, path: Path, value: Vec<u8>, ) -> Result<Option<Vec<u8>>, Self::Error>

Set value for path

fn get(&self, height: Height, path: &Path) -> Option<Vec<u8>>

Get associated value for path at specified height

fn delete(&mut self, path: &Path)

Delete specified path

fn commit(&mut self) -> Result<Vec<u8>, Self::Error>

Commit Pending block to canonical chain and create new Pending

fn apply(&mut self) -> Result<(), Self::Error>

Apply accumulated changes to Pending

fn current_height(&self) -> u64

Return the current height of the chain

fn get_keys(&self, key_prefix: &Path) -> Vec<Path>

Return all keys that start with specified prefix

fn prune(&mut self, height: RawHeight) -> Result<RawHeight, Self::Error>

Prune historic blocks upto specified height