Struct WanIdentityStore 

pub struct WanIdentityStore {
    conn: Mutex<Connection>,
}

Fields

conn: Mutex<Connection>

Implementations

impl WanIdentityStore

const AGENT_KEY_COLUMNS: &'static str = "public_key, private_key, imported, created_at"

pub fn open(path: &Path) -> Result<Self, StoreError>

Open (creating if needed) the store at path. Errors if the file can’t be opened or its schema can’t be ensured; the caller then runs without WAN identity.

pub fn instance_ensure(&self, hostname: &str) -> Result<WanInstance, StoreError>

This install’s instance, minted on first call. hostname is read only at mint time and becomes the permanent host hint.

fn instance_load(conn: &Connection) -> Result<Option<WanInstance>, StoreError>

pub fn agent_key_load( &self, agent_id: &str, ) -> Result<Option<WanAgentKey>, StoreError>

An agent’s WAN key, if this store holds one.

fn agent_key_from_row(r: &Row<'_>, offset: usize) -> Result<WanAgentKey>

fn agent_key_load_locked( conn: &Connection, key: &str, ) -> Result<Option<WanAgentKey>, StoreError>

pub fn agent_keys_unpublished( &self, directory: &str, ) -> Result<Vec<(String, WanAgentKey)>, StoreError>

Every agent key directory is not confirmed to hold, by agent id — what the publisher (muxbus/wan_publish.rs) works through.

pub fn agent_key_is_published_to( &self, agent_id: &str, key: &WanAgentKey, directory: &str, ) -> Result<bool, StoreError>

Whether directory is confirmed to hold key, agent_id’s current key — the relay carry gate’s condition 4 (relay::wan_carry_gate).

fn fp_matches(key: &WanAgentKey, published_fp: Option<&str>) -> bool

pub fn agent_key_mark_published( &self, agent_id: &str, public_key: &str, directory: &str, ) -> Result<bool, StoreError>

Record that directory accepted public_key’s certificate. Only marks if the row still holds that key — an agent deleted and recreated while the PUT was in flight must not have its new key marked published on the strength of the old one’s. directory must be the one the PUT went to, so a PUT that returns after a sign-in to another account marks the old directory, not the new one.

pub fn agent_key_ensure( &self, agent_id: &str, import: Option<(&str, &str)>, ) -> Result<WanAgentKey, StoreError>

An agent’s WAN key, created on first call: import (the agent’s key from this version’s db_agent_wan_keys, read by the caller) is carried over if given, otherwise a fresh key is minted. Only the first call for an agent decides — after that, import is ignored, so an agent keeps one key across upgrades. Case-insensitive, like every key table.

pub fn peer_record_get( &self, instance_id: &str, agent_id: &str, channel: &str, key_fp: &str, ) -> Result<Option<WanKeyRecord>, StoreError>

A cached directory record for exactly this (instance, agent, channel, fingerprint). The caller re-checks its chain; a row that no longer parses is treated as absent.

pub fn peer_record_put(&self, record: &WanKeyRecord) -> Result<(), StoreError>

Cache a record whose chain the caller has checked.

pub fn peer_cache_clear(&self) -> Result<(), StoreError>

Forget every cached peer record — on logout or account switch (§2.3).

pub fn known_instance_observe( &self, instance_id: &str, host_hint: &str, now: i64, ) -> Result<KnownInstance, StoreError>

Record instance_id as seen (first sight inserts it) and return what is known about it.

pub fn known_instance_record_revocation_check( &self, instance_id: &str, revoked: bool, now: i64, ) -> Result<(), StoreError>

Record a revocation-status check. revoked is sticky: a later check that says “not revoked” never clears it.

pub fn seen_sig_contains( &self, instance_id: &str, agent_id: &str, msg_id: &str, ) -> Result<bool, StoreError>

Whether this (instance, agent, msgid) was already delivered.

pub fn seen_sig_record( &self, instance_id: &str, agent_id: &str, msg_id: &str, expires_at: i64, now: i64, ) -> Result<(), StoreError>

Record a delivered signature until expires_at, and prune the rows that could no longer pass freshness at now — the same clock the verifier’s freshness check used, so a row is never pruned while its message could still verify.

pub fn agent_keys_delete(&self, names: &[String]) -> Result<usize, StoreError>

Delete the keys filed under each name (folded as the key tables fold). The agent-delete purge (storage/agents/name_keys.rs) passes exactly the names it decided no other agent signs under, so a later agent that takes a name never inherits the dead agent’s key. Returns rows removed.