use anyhow::Result;
use second_brain_core::keys::{Epoch, PeerView};
use serde::Serialize;
use super::Keyring;
use crate::protocol::HandshakeKeys;
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
pub struct IdentityStatus {
pub identity: Option<String>,
pub epochs: Vec<u32>,
pub removed: bool,
pub possibly_revoked: bool,
pub row_accepted: Option<bool>,
pub peers: Vec<PeerStanding>,
pub retired_recovery: Vec<RetiredPhrase>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct RetiredPhrase {
pub fingerprint: String,
pub retired_by: Option<String>,
pub at_micros: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct PeerStanding {
pub peer: String,
pub heard_at_micros: i64,
pub holds_own_row: bool,
pub lacking: Vec<u32>,
}
impl Keyring<'_> {
pub fn status(&self) -> Result<IdentityStatus> {
let Some(tag) = &self.identity else {
return Ok(IdentityStatus::default());
};
let removed = self.is_removed()?;
let mut peers = Vec::new();
for view in self.store.peer_views(tag)? {
if self.active_row(&view.peer)?.is_none() {
continue;
}
peers.push(PeerStanding {
peer: view.peer,
heard_at_micros: view.heard_at_micros,
holds_own_row: view.holds_own_row,
lacking: view.lacking.iter().map(|e| e.number).collect(),
});
}
let row_accepted = (!peers.is_empty()).then(|| peers.iter().any(|p| p.holds_own_row));
let possibly_revoked = removed
|| peers
.iter()
.any(|p| p.holds_own_row && !p.lacking.is_empty());
let mut epochs: Vec<u32> = self.stored_epochs()?.iter().map(|e| e.number).collect();
epochs.sort_unstable();
epochs.dedup();
let retired_recovery = self
.store
.retired_under(tag)?
.into_iter()
.map(|(fingerprint, signed)| RetiredPhrase {
retired_by: signed
.as_ref()
.map(|s| self.device_name(&s.retirement.retirer)),
at_micros: signed.as_ref().map(|s| s.retirement.created_at_micros),
fingerprint,
})
.collect();
Ok(IdentityStatus {
identity: Some(tag.as_str().to_string()),
epochs,
removed,
possibly_revoked,
row_accepted,
peers,
retired_recovery,
})
}
pub(super) fn record_peer_view(
&self,
peer: &str,
keys: &HandshakeKeys,
now_micros: i64,
) -> Result<()> {
let Some(tag) = &self.identity else {
return Ok(());
};
if peer == self.own() {
return Ok(());
}
let own_key = self.device.verifying_key();
let holds_own_row = keys.devices.iter().any(|row| {
row.record.machine_id == self.own()
&& row.record.identity_tag == tag.as_str()
&& row
.record
.signing_public_key()
.is_ok_and(|key| key == own_key)
});
let held = self.stored_epochs()?;
let lacking = keys
.epochs
.iter()
.filter(|epoch| !held.contains(epoch))
.copied()
.collect();
self.store.record_peer_view(
tag,
&PeerView {
peer: peer.to_string(),
heard_at_micros: now_micros,
holds_own_row,
lacking,
},
)
}
fn stored_epochs(&self) -> Result<Vec<Epoch>> {
let recipient = self.device.age_recipient().to_string();
Ok(self
.store
.own_identity_envelopes(&recipient)?
.map(|(_, envelopes)| envelopes.into_iter().map(|e| e.epoch).collect())
.unwrap_or_default())
}
}