Struct Any

pub struct Any<E: RStorage + Clock + Metrics, K: Array, V: Array, H: CHasher, T: Translator> { /* private fields */ }

A key-value ADB based on an MMR over its log of operations, supporting authentication of any value ever associated with a key.

Implementations

impl<E: RStorage + Clock + Metrics, K: Array, V: Array, H: CHasher, T: Translator> Any<E, K, V, H, T>

pub async fn init(context: E, cfg: Config<T>) -> Result<Self, Error>

Returns any Any adb initialized from cfg. Any uncommitted log operations will be discarded and the state of the db will be as of the last committed operation.

pub fn op_digest(hasher: &mut Standard<H>, op: &Operation<K, V>) -> H::Digest

Return a digest of the operation.

pub async fn get(&self, key: &K) -> Result<Option<V>, Error>

Get the value of key in the db, or None if it has no value.

pub fn op_count(&self) -> u64

Get the number of operations that have been applied to this db, including those that are not yet committed.

pub fn oldest_retained_loc(&self) -> Option<u64>

Return the oldest location that remains readable & provable.

pub async fn update(&mut self, key: K, value: V) -> Result<UpdateResult, Error>

Updates key to have value value. If the key already has this same value, then this is a no-op. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit.

pub async fn delete(&mut self, key: K) -> Result<Option<u64>, Error>

Delete key and its value from the db. Deleting a key that already has no value is a no-op. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit. Returns the location of the deleted value for the key (if any).

pub fn root(&self, hasher: &mut Standard<H>) -> H::Digest

Return the root of the db.

Warning

Panics if there are uncommitted operations.

pub async fn proof( &self, start_loc: u64, max_ops: u64, ) -> Result<(Proof<H::Digest>, Vec<Operation<K, V>>), Error>

Generate and return:

1. a proof of all operations applied to the db in the range starting at (and including) location start_loc, and ending at the first of either:
   • the last operation performed, or
   • the operation max_ops from the start.
2. the operations corresponding to the leaves in this range.

Warning

Panics if there are uncommitted operations.

pub async fn historical_proof( &self, size: u64, start_loc: u64, max_ops: u64, ) -> Result<(Proof<H::Digest>, Vec<Operation<K, V>>), Error>

Analagous to proof but for a previous database state. Specifically, the state when the MMR had size elements.

pub fn verify_proof( hasher: &mut Standard<H>, proof: &Proof<H::Digest>, start_loc: u64, ops: &[Operation<K, V>], root_digest: &H::Digest, ) -> bool

Return true if the given sequence of ops were applied starting at location start_loc in the log with the provided root.

pub async fn commit(&mut self) -> Result<(), Error>

Commit any pending operations to the db, ensuring they are persisted to disk & recoverable upon return from this function. Also raises the inactivity floor according to the schedule, and prunes those operations below it. Batch operations will be parallelized if a thread pool is provided.

pub async fn close(self) -> Result<(), Error>

Close the db. Operations that have not been committed will be lost.

pub async fn destroy(self) -> Result<(), Error>

Destroy the db, removing all data from disk.

Trait Implementations

impl<E, K, V, H, T> Resolver for &Any<E, K, V, H, T>

where E: Storage + Clock + Metrics, K: Array, V: Array, H: Hasher, T: Translator,

type Digest = <H as Hasher>::Digest

type Key = K

type Value = V

async fn get_operations( &self, size: u64, start_loc: u64, max_ops: NonZeroU64, ) -> Result<GetOperationsResult<H::Digest, Self::Key, Self::Value>, Error>

The digest type of the resolver. Get the operations starting at start_loc in the database, up to max_ops operations. Returns the operations and a proof that they were present in the database when it had size operations.