Struct CompactDb 

pub struct CompactDb<F, E, V, H, C, S: Strategy>
where
    F: Family,
    E: Context,
    V: ValueEncoding,
    H: Hasher,
    Operation<F, V>: EncodeShared + Read<Cfg = C>,
    C: Clone + Send + Sync + 'static,
{ /* private fields */ }

A keyless authenticated db that does not retain historical operations after sync.

Implementations

impl<F, E, V, H, C, S> Db<F, E, V, H, C, S>

where F: Family, E: Context, V: ValueEncoding, H: Hasher, S: Strategy, Operation<F, V>: EncodeShared + Read<Cfg = C>, C: Clone + Send + Sync + 'static,

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

where F: Family,

Return the root of the db.

pub const fn strategy(&self) -> &S

Return a reference to the merkleization strategy.

pub const fn last_commit_loc(&self) -> Location<F>

Return the location of the last commit.

pub const fn inactivity_floor_loc(&self) -> Location<F>

Return the inactivity floor declared by the last committed batch.

pub fn size(&self) -> Location<F>

Return the location of the next operation appended to this db.

pub fn get_metadata(&self) -> Option<V::Value>

Get the metadata associated with the last commit.

pub fn current_target(&self) -> Target<F, H::Digest>

Return the compact-sync target described by the current witness.

This reflects the last state for which both frontier and witness were durably captured, which may lag behind live in-memory mutations until Self::sync is called.

pub fn new_batch(&self) -> UnmerkleizedBatch<F, H, V, S>

Create a new speculative batch of operations with this database as its parent.

pub fn to_batch(&self) -> Arc<MerkleizedBatch<F, H::Digest, V, S>>

where F: Family,

Create an owned merkleized batch representing the current committed state.

pub fn apply_batch( &mut self, batch: Arc<MerkleizedBatch<F, H::Digest, V, S>>, ) -> Result<Range<Location<F>>, Error<F>>

Apply a merkleized batch to the database.

Returns the range of locations written. The state is updated in memory only; call Self::sync or Self::commit to persist.

Errors

• Error::StaleBatch if the batch was created from a stale DB state.
• Error::FloorRegressed if any unapplied commit’s floor is below the running floor (walking ancestors oldest-first, then the tip).
• Error::FloorBeyondSize if any unapplied commit’s floor exceeds its own commit location.

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

Durably persist the current db state to disk.

This is the point at which in-memory mutations become servable via compact sync. The compact Merkle frontier and last-commit witness are written into the same slot, reusing the cached witness when the current state has already been persisted.

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

where F: Family,

Durably persist the current db state to disk (alias for Self::sync).

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

where F: Family,

Restore the state as of the sync before the most recent one.

Discards any uncommitted batches, flips the db back to the previous persisted state, and reloads the cached commit metadata and inactivity floor from that slot.

Callers must drop any Arc<MerkleizedBatch> merkleized against state that this rewind discards. Self::apply_batch validates batches by size only: a discarded-branch batch will usually trip the size-mismatch check, but if the db later regrows to the same size along an alternate branch, the stale batch becomes admissible again and applying it will corrupt the committed root. Batches merkleized against the state this rewind restores to (for example, a batch built before an advance that is then discarded by the rewind) remain compatible and apply cleanly.

Errors

Returns crate::merkle::Error::RewindBeyondHistory (wrapped as Error::Merkle) if no prior state exists — either no sync has occurred yet, or the previous state was already consumed by a rewind with no intervening sync.

Any error from this method is fatal for this handle. The Merkle layer may have already flipped its generation pointer and rebuilt its in-memory state before a later step (e.g. reloading the cached commit metadata or inactivity floor) fails, leaving this Db’s in-memory fields out of sync with the persisted slot. Callers must drop this handle after any Err from rewind and reopen from storage.

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

Destroy all persisted state associated with this database.

impl<F: Family, E: Storage + Clock + Metrics, V: FixedValue, H: Hasher, S: Strategy> Db<F, E, FixedEncoding<V>, H, (), S>

pub async fn init(context: E, cfg: CompactConfig<S>) -> Result<Self, Error<F>>

Returns a CompactDb initialized from cfg.

impl<F: Family, E: Storage + Clock + Metrics, V: VariableValue, H: Hasher, C: Clone + Send + Sync + 'static, S: Strategy> Db<F, E, VariableEncoding<V>, H, C, S>

where Operation<F, V>: Read<Cfg = C>,

pub async fn init( context: E, cfg: CompactConfig<C, S>, ) -> Result<Self, Error<F>>

Returns a CompactDb initialized from cfg.

Trait Implementations

impl<F, E, V, H, Cfg, S> Database for CompactDb<F, E, V, H, Cfg, S>

where F: Family, E: Context, V: ValueEncoding + Codec, H: Hasher, S: Strategy, Operation<F, V>: EncodeShared + Read<Cfg = Cfg>, Cfg: Clone + Send + Sync + 'static,

type Family = F

type Op = Operation<F, V>

type Config = Config<Cfg, S>

type Digest = <H as Hasher>::Digest

type Context = E

type Hasher = H

async fn from_validated_state( context: Self::Context, config: Self::Config, state: ValidatedState<Self::Family, Self::Op, Self::Digest>, ) -> Result<Self, Error<F>>

Build a database from authenticated state in memory.

fn inactivity_floor(op: &Self::Op) -> Option<Location<Self::Family>>

Return the inactivity floor if the operation is a commit.

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

Get the root digest for final verification.

async fn persist_compact_state(&self) -> Result<(), Error<F>>

Persist the compact-initialized state once the caller has verified its root.