Struct Current 

pub struct Current<E: RStorage + Clock + Metrics, K: Array, V: CodecFixed<Cfg = ()> + Clone, H: CHasher, T: Translator, const N: usize> {
    pub any: Any<E, K, V, H, T>,
    pub status: Bitmap<H, N>,
    /* private fields */
}

A key-value ADB based on an MMR over its log of operations, supporting authentication of whether a key ever had a specific value, and whether the key currently has that value.

Note: The generic parameter N is not really generic, and must be manually set to double the size of the hash digest being produced by the hasher. A compile-time assertion is used to prevent any other setting.

Fields

any: Any<E, K, V, H, T>

An Any authenticated database that provides the ability to prove whether a key ever had a specific value.

status: Bitmap<H, N>

The bitmap over the activity status of each operation. Supports augmenting Any proofs in order to further prove whether a key currently has a specific value.

Implementations

impl<E: RStorage + Clock + Metrics, K: Array, V: CodecFixed<Cfg = ()> + Clone, H: CHasher, T: Translator, const N: usize> Current<E, K, V, H, T, N>

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

Initializes a Current authenticated database from the given config. Leverages parallel Merkleization to initialize the bitmap MMR if a thread pool is provided.

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 inactivity_floor_loc(&self) -> u64

Return the inactivity floor location. Locations prior to this point can be safely pruned.

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 async fn get_loc(&self, loc: u64) -> Result<Option<V>, Error>

Get the value of the operation with location loc in the db. Returns Error::OperationPruned if loc precedes the oldest retained location. The location is otherwise assumed valid.

pub async fn update(&mut self, key: K, value: V) -> Result<(), 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<(), 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.

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. Leverages parallel Merkleization of the MMR structures if a thread pool is provided.

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

Sync data to disk, ensuring clean recovery.

pub async fn prune(&mut self, target_prune_loc: u64) -> Result<(), Error>

Prune all operations prior to target_prune_loc from the db.

Panic

Panics if target_prune_loc is greater than the inactivity floor.

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

Return the root of the db.

Warning

Panics if there are uncommitted operations.

pub async fn range_proof( &self, hasher: &mut H, start_loc: u64, max_ops: NonZeroU64, ) -> Result<(Proof<H::Digest>, Vec<Fixed<K, V>>, Vec<[u8; N]>), Error>

Returns a proof that the specified range of operations are part of the database, along with the operations from the range. A truncated range (from hitting the max) can be detected by looking at the length of the returned operations vector. Also returns the bitmap chunks required to verify the proof.

Panics

Panics if there are uncommitted operations or if start_loc is invalid.

pub fn verify_range_proof( hasher: &mut Standard<H>, proof: &Proof<H::Digest>, start_loc: u64, ops: &[Fixed<K, V>], chunks: &[[u8; N]], root: &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 key_value_proof( &self, hasher: &mut H, key: K, ) -> Result<(Proof<H::Digest>, KeyValueProofInfo<K, V, N>), Error>

Generate and return a proof of the current value of key, along with the other KeyValueProofInfo required to verify the proof. Returns KeyNotFound error if the key is not currently assigned any value.

Warning

Panics if there are uncommitted operations.

pub fn verify_key_value_proof( hasher: &mut H, proof: &Proof<H::Digest>, info: &KeyValueProofInfo<K, V, N>, root: &H::Digest, ) -> bool

Return true if the proof authenticates that key currently has value value in the db with the given root.

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.