Struct Keyless 

pub struct Keyless<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, M: MerkleizationState<DigestOf<H>> = Merkleized<H>, D: DurabilityState = Durable> { /* private fields */ }

A keyless authenticated database for variable-length data.

Implementations

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, M: MerkleizationState<DigestOf<H>>, D: DurabilityState> Keyless<E, V, H, M, D>

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

Get the value at location loc in the database.

Errors

Returns Error::LocationOutOfBounds if loc >= self.op_count().

pub fn op_count(&self) -> Location

Get the number of operations (appends + commits) that have been applied to the db since inception.

pub const fn last_commit_loc(&self) -> Location

Returns the location of the last commit.

pub fn oldest_retained_loc(&self) -> Location

Return the oldest location that remains retrievable.

pub fn inactivity_floor_loc(&self) -> Location

Return the oldest location that is no longer required to be retained.

pub async fn get_metadata(&self) -> Result<Option<V>, Error>

Get the metadata associated with the last commit.

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher> Keyless<E, V, H, Merkleized<H>, Durable>

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

Returns a Keyless qmdb initialized from cfg. Any uncommitted operations will be discarded and the state of the db will be as of the last committed operation.

pub const fn root(&self) -> H::Digest

Return the root of the db.

pub async fn proof( &self, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<H::Digest>, Vec<Operation<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.

pub async fn historical_proof( &self, op_count: Location, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<H::Digest>, Vec<Operation<V>>), Error>

Analogous to proof, but with respect to the state of the MMR when it had op_count operations.

Errors

• Returns crate::mmr::Error::LocationOverflow if op_count or start_loc > crate::mmr::MAX_LOCATION.
• Returns crate::mmr::Error::RangeOutOfBounds if start_loc >= op_count or op_count > number of operations.

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

Prune historical operations prior to loc. This does not affect the db’s root.

Errors

• Returns Error::PruneBeyondMinRequired if loc > last commit point.
• Returns crate::mmr::Error::LocationOverflow if loc > crate::mmr::MAX_LOCATION

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

Sync all database state to disk. While this isn’t necessary to ensure durability of committed operations, periodic invocation may reduce memory usage and the time required to recover the database on restart.

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

Destroy the db, removing all data from disk.

pub fn into_mutable(self) -> Keyless<E, V, H, Unmerkleized, NonDurable>

Convert this database into the Mutable state for accepting new operations.

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher> Keyless<E, V, H, Unmerkleized, NonDurable>

pub async fn append(&mut self, value: V) -> Result<Location, Error>

Append a value to the db, returning its location which can be used to retrieve it.

pub async fn commit( self, metadata: Option<V>, ) -> Result<(Keyless<E, V, H, Unmerkleized, Durable>, Range<Location>), Error>

Commits any pending operations and transitions the database to the Durable state.

The caller can associate an arbitrary metadata value with the commit. Returns the (start_loc, end_loc] location range of committed operations. The end of the returned range includes the commit operation itself, and hence will always be equal to op_count.

pub fn into_merkleized(self) -> Keyless<E, V, H, Merkleized<H>, Durable>

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher> Keyless<E, V, H, Unmerkleized, Durable>

pub fn into_mutable(self) -> Keyless<E, V, H, Unmerkleized, NonDurable>

Convert this database into the Mutable state for accepting more operations without re-merkleizing.

pub fn into_merkleized(self) -> Keyless<E, V, H, Merkleized<H>, Durable>

Compute the merkle root and transition to the Merkleized, Durable state.

Trait Implementations

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, M: MerkleizationState<DigestOf<H>>, D: DurabilityState> LogStore for Keyless<E, V, H, M, D>

type Value = V

fn is_empty(&self) -> bool

Returns true if there are no active keys in the database.

fn op_count(&self) -> Location

The number of operations that have been applied to this db, including those that have been pruned and those that are not yet committed.

fn inactivity_floor_loc(&self) -> Location

Return the inactivity floor location. This is the location before which all operations are known to be inactive. Operations before this point can be safely pruned.

async fn get_metadata(&self) -> Result<Option<Self::Value>, Error>

Get the metadata associated with the last commit.

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, D: DurabilityState> MerkleizedStore for Keyless<E, V, H, Merkleized<H>, D>

type Digest = <H as Hasher>::Digest

The digest type used for authentication.

type Operation = Operation<V>

The operation type stored in the log.

fn root(&self) -> Self::Digest

Returns the root digest of the authenticated store.

async fn historical_proof( &self, historical_size: Location, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<Self::Digest>, Vec<Self::Operation>), Error>

Generate and return:

fn proof( &self, start_loc: Location, max_ops: NonZeroU64, ) -> impl Future<Output = Result<(Proof<Self::Digest>, Vec<Self::Operation>), Error>> + Send

Generate and return:

impl<E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, D: DurabilityState> PrunableStore for Keyless<E, V, H, Merkleized<H>, D>

async fn prune(&mut self, loc: Location) -> Result<(), Error>

Prune historical operations prior to loc.