Struct InMemory 

pub struct InMemory { /* private fields */ }

A simple in-memory database implementation using a HashMap for storage.

This database is suitable for testing, development, or scenarios where data persistence is not strictly required or is handled externally (e.g., by saving/loading the entire state to/from a file).

It provides basic persistence capabilities via save_to_file and load_from_file, serializing the HashMap to JSON.

Security Note: The device key is stored in memory in plaintext in this implementation. This is acceptable for development and testing but should not be used in production without proper encryption or hardware security module integration.

Implementations

impl InMemory

pub fn new() -> Self

Creates a new, empty InMemory database.

pub async fn all_ids(&self) -> Vec<ID>

Returns a vector containing the IDs of all entries currently stored in the database.

pub fn save_to_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Saves the entire database state (all entries) to a specified file as JSON.

The write is atomic on POSIX (writes to <path>.tmp then renames into place). On Windows the final rename is not atomic when the destination already exists.

This is synchronous — the body is just std::fs::write + rename with no await points — so it’s safe to call from Drop impls and other non-async contexts. Callers on a tokio runtime should be aware that the write briefly blocks the calling worker thread.

Arguments

• path - The path to the file where the state should be saved.

Returns

A Result indicating success or an I/O or serialization error.

pub async fn load_from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Loads the database state from a specified JSON file.

If the file does not exist, a new, empty InMemory database is returned. Callers that need to tell “missing” apart from “loaded empty” should use Self::try_load_from_file.

Arguments

• path - The path to the file from which to load the state.

Returns

A Result containing the loaded InMemory database or an I/O or deserialization error.

pub async fn try_load_from_file<P: AsRef<Path>>(path: P) -> Result<Option<Self>>

Like Self::load_from_file, but returns Ok(None) when the file does not exist instead of falling back to an empty backend. Lets callers distinguish “no snapshot yet” from “snapshot loaded as empty” without a separate path.exists() round-trip (and the TOCTOU window that comes with it).

pub fn sort_entries_by_height(&self, _tree: &ID, entries: &mut [Entry])

Sort entries by their height within a tree (exposed for testing)

Heights are stored directly in entries, so this just reads and sorts.

Arguments

• _tree - The ID of the tree context (unused, kept for API compatibility)
• entries - The vector of entries to be sorted in place

pub fn sort_entries_by_subtree_height( &self, _tree: &ID, subtree: &str, entries: &mut [Entry], )

Sort entries by their height within a subtree (exposed for testing)

Heights are stored directly in entries, so this just reads and sorts.

Arguments

• _tree - The ID of the tree context (unused, kept for API compatibility)
• subtree - The name of the subtree context
• entries - The vector of entries to be sorted in place

pub async fn is_tip(&self, tree: &ID, entry_id: &ID) -> bool

Check if an entry is a tip within its tree (exposed for benchmarks)

An entry is a tip if no other entry in the same tree lists it as a parent.

Arguments

• tree - The ID of the tree to check within
• entry_id - The ID of the entry to check

Returns

true if the entry is a tip, false otherwise

Trait Implementations

impl BackendImpl for InMemory

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Entry>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves an entry by its unique content-addressable ID.

Arguments

• id - The ID of the entry to retrieve.

Returns

A Result containing the Entry if found, or a DatabaseError::EntryNotFound otherwise. Returns an owned copy to support concurrent access with internal synchronization.

fn get_verification_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<VerificationStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets the verification status of an entry.

Arguments

• id - The ID of the entry to check.

Returns

A Result containing the VerificationStatus if the entry exists, or a DatabaseError::VerificationStatusNotFound otherwise.

fn update_verification_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, verification_status: VerificationStatus, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Updates the verification status of an existing entry.

This allows the authentication system to mark entries as verified or failed after they have been stored. Useful for batch verification operations.

Arguments

• id - The ID of the entry to update
• verification_status - The new verification status

Returns

A Result indicating success or DatabaseError::EntryNotFound if the entry doesn’t exist.

fn get_entries_by_verification_status<'life0, 'async_trait>( &'life0 self, status: VerificationStatus, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all entries with a specific verification status.

This is useful for finding unverified entries that need authentication or for security audits.

Arguments

• status - The verification status to filter by

Returns

A Result containing a vector of entry IDs with the specified status.

fn all_roots<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieves the IDs of all top-level root entries stored in the database.

Top-level roots are entries that are themselves roots of a tree (i.e., entry.is_root() is true) and are not part of a larger tree structure tracked by the backend. These represent the starting points of distinct trees managed by the database.

Returns

A Result containing a vector of top-level root entry IDs or an error.

fn put<'life0, 'async_trait>( &'life0 self, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stores an entry.

fn snapshot<'life0, 'life1, 'async_trait>( &'life0 self, tree: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the current Snapshot of tree — its sorted, deduplicated set of DAG tips.

fn store_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns the snapshot of a specific store within a given tree.

fn store_snapshot_at<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, main_snapshot: &'life3 Snapshot, ) -> Pin<Box<dyn Future<Output = Result<Snapshot>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Returns the store snapshot as of a specific main-tree snapshot.

fn find_merge_base<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, entry_ids: &'life3 [ID], ) -> Pin<Box<dyn Future<Output = Result<ID>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Finds the merge base (common dominator) of the given entry IDs within a store.

fn collect_root_to_target<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, target_entry: &'life3 ID, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Collects all entries from the tree root down to the target entry within a store.

fn as_any(&self) -> &dyn Any

Returns a reference to the backend instance as a dynamic Any type.

fn get_tree<'life0, 'life1, 'async_trait>( &'life0 self, tree: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves all entries belonging to a specific tree, sorted topologically.

fn get_store<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves all entries belonging to a specific store within a tree, sorted topologically.

fn get_tree_from_tips<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, tips: &'life2 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves all entries belonging to a specific tree up to the given tips, sorted topologically.

fn store_at<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, subtree: &'life2 str, snapshot: &'life3 Snapshot, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Retrieves all entries belonging to a specific store at the given snapshot, sorted topologically.

fn get_instance_metadata<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<InstanceMetadata>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the instance metadata.

fn set_instance_metadata<'life0, 'life1, 'async_trait>( &'life0 self, metadata: &'life1 InstanceMetadata, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the instance metadata.

fn get_instance_secrets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<InstanceSecrets>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the instance secrets (private key material).

fn set_instance_secrets<'life0, 'life1, 'async_trait>( &'life0 self, secrets: &'life1 InstanceSecrets, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the instance secrets (private key material).

fn get_cached_crdt_state<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, scope: &'life1 CacheScope, entry_id: &'life2 ID, subtree: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get cached CRDT state for a store at a specific entry within a scope.

fn cache_crdt_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: CacheScope, entry_id: &'life1 ID, subtree: &'life2 str, state: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Cache CRDT state for a store at a specific entry within a scope.

fn clear_crdt_cache<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear all cached CRDT states.

fn get_sorted_store_parents<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree_id: &'life1 ID, entry_id: &'life2 ID, subtree: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get the store parent IDs for a specific entry and store, sorted by height then ID.

fn get_path_from_to<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tree_id: &'life1 ID, subtree: &'life2 str, from_id: &'life3 ID, to_ids: &'life4 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Gets all entries between one entry and multiple target entries (exclusive of start, inclusive of targets).

impl Debug for InMemory

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

Formats the value using the given formatter.

impl Default for InMemory

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for InMemory

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for InMemory

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.