lib: a node-bearing record hands back its NodePubkey, not hex
Build Debug APK / build (push) Failing after 2m37s

DelegationCert, RegistryMember, PeerNode and RevocationRecord each kept
their own node_id_hex, and two of them a node_short_id that cut the key
with no ellipsis. Each now has one typed accessor — node(), or
revoked_node() on a revocation — and callers say .to_hex() or
.short_id() on what it returns, so a shortened node id goes through
copy::short_id like every other. The NodePubkey(x.node_pubkey) wrappers
at call sites fold into the same accessor.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Greg ShuflinandClaude Opus 5.5 committed 2026-10-03 15:54:11 -07:00
1 parent 7b25aadf91
commit bb88bdacce
20 files changed
+58 -74

No files matched your search

+2 -2
View File
@@ -162,8 +162,8 @@ held hostage to.
**Filename disambiguation:** ad hoc, no need to over-engineer — the first sibling to claim a
slugified name keeps it bare; any later sibling that collides gets `-<short document ID>`
appended (before the extension, for notes), first-seen order, using the same 8-hex-char
truncation convention as `PeerNode::node_short_id`. Not stable across re-runs if sibling
appended (before the extension, for notes), first-seen order, using the same 8-character
prefix as `copy::short_id`, without its ellipsis. Not stable across re-runs if sibling
order or titles change (a different document could claim the bare name next time), which is
fine for a stateless, always-overwrite exporter — and unlike a numeric counter, the suffix
that does get used is at least always unambiguous and traceable back to one document.
+1 -1
View File
@@ -294,7 +294,7 @@ fn registry_row(m: &RegistryMember, mark: Option<ColoredString>) -> String {
.map(|dt| dt.format("%Y-%m-%d").to_string())
.unwrap_or_else(|| "?".to_string());
let suffix = mark.map(|mark| format!(" {mark}")).unwrap_or_default();
format!(" [{}] \"{name}\" registered {registered}{suffix}", m.node_id_hex().bold())
format!(" [{}] \"{name}\" registered {registered}{suffix}", m.node().to_hex().bold())
}
/// Combined gossip discovery status: DHT registry, gossip peer snapshot, and
@@ -2037,7 +2037,7 @@ pub(super) fn ensemble_peer_ids(store: &Store) -> Result<Vec<NodePubkey>, String
if peers.is_empty() {
return Err("no peers available to sync from".to_string());
}
Ok(peers.iter().map(|p| NodePubkey(p.node_pubkey)).collect())
Ok(peers.iter().map(|p| p.node()).collect())
}
/// Every node in the user's ensemble as a Placement row — **this node first**,
@@ -2122,8 +2122,8 @@ pub(super) fn placement_rows(
})
.unwrap_or_default();
rows.extend(peers.into_iter().filter(|p| NodePubkey(p.node_pubkey) != local_node).map(|p| {
let node_pubkey = NodePubkey(p.node_pubkey);
rows.extend(peers.into_iter().filter(|p| p.node() != local_node).map(|p| {
let node_pubkey = p.node();
let (name, name_is_placeholder) = node_display::resolve(p.display_name.as_deref());
PlacementRow {
node_pubkey,
@@ -251,7 +251,7 @@ fn load_nodes(
})
.map_err(|e| e.to_string())?;
for peer in peers {
let pubkey = NodePubkey(peer.node_pubkey);
let pubkey = peer.node();
if pubkey == local_node {
continue;
}
+2 -2
View File
@@ -19,7 +19,7 @@ use gpui::{
use synchronicity::agents::AgentId;
use synchronicity::copy::peer_health::PeerHealthCopy;
use synchronicity::copy::{
PeerSyncCopy, action, busy, ensemble_roster, format_last_seen, revocation, short_id,
PeerSyncCopy, action, busy, ensemble_roster, format_last_seen, revocation,
};
use synchronicity::ensemble::retire;
use synchronicity::ensemble::screen::RosterCounts;
@@ -516,7 +516,7 @@ impl EnsembleView {
move |this, applied, cx| {
this.import_result = Some(match applied {
Ok((record, learned)) => {
let node = short_id(&record.node_id_hex());
let node = record.revoked_node().short_id();
Ok(if learned {
revocation::revoked(&node).into()
} else {
+1 -1
View File
@@ -616,7 +616,7 @@ pub(super) fn load_remote_peers(store: &Store) -> Vec<(NodePubkey, SharedString)
.into_iter()
.map(|p| {
let (name, _is_placeholder) = node_display::resolve(p.display_name.as_deref());
(NodePubkey(p.node_pubkey), name.into())
(p.node(), name.into())
})
.collect()
}
+3 -2
View File
@@ -275,8 +275,9 @@ fn disambiguate(
if *count == 1 { key } else { format!("{base}-{}{suffix}", short_id(id)) }
}
/// First 8 characters of a `DocumentID`'s UUID string — same truncation convention as
/// `PeerNode::node_short_id`.
/// First 8 characters of a `DocumentID`'s UUID string — the prefix
/// [`copy::short_id`](crate::copy::short_id) shows, without its ellipsis, since this goes in a
/// filename.
fn short_id(id: &DocumentID) -> String {
id.to_string()[..8].to_string()
}
+8 -16
View File
@@ -16,6 +16,7 @@
//! Day-to-day P2P activity requires only the node keypair. The ensemble public key
//! (stored in [`EnsembleMembership`]) is used as the pkarr address for fleet discovery.
use crate::node::NodePubkey;
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use iroh::{KeyParsingError, PublicKey, Signature, SignatureError};
use pkarr::{Client as PkarrClient, Keypair as PkarrKeypair, SignedPacket, dns::rdata::RData};
@@ -181,9 +182,9 @@ impl DelegationCert {
PublicKey::from_bytes(&self.node_pubkey).map_err(EnsembleError::InvalidNodePubkey)
}
/// Hex-encoded node public key (64 hex chars).
pub fn node_id_hex(&self) -> String {
hex::encode(self.node_pubkey)
/// The node this cert delegates to.
pub fn node(&self) -> NodePubkey {
NodePubkey(self.node_pubkey)
}
/// This cert's stable identity: blake3 over the bytes it is signed across.
@@ -372,18 +373,9 @@ pub struct RegistryMember {
}
impl RegistryMember {
/// Hex-encoded node public key (iroh NodeId representation).
pub fn node_id_hex(&self) -> String {
hex::encode(self.node_pubkey)
}
/// Short hex identifier (first 8 hex chars / 4 bytes).
///
/// TODO: introduce a dedicated truncated-display helper so callers can choose
/// between a short form for dense UIs and the full ID. For now all display
/// sites use the full [`node_id_hex`](Self::node_id_hex).
pub fn node_short_id(&self) -> String {
hex::encode(&self.node_pubkey[..4])
/// The registered node.
pub fn node(&self) -> NodePubkey {
NodePubkey(self.node_pubkey)
}
/// Human-readable creation date string (e.g. `"2024-01-15"`).
@@ -499,7 +491,7 @@ pub async fn publish_membership(
.collect();
while estimated_packet_size(&encoded) > PKARR_PACKET_LIMIT && encoded.len() > 1 {
let evicted_id = entries[0].0.node_short_id();
let evicted_id = entries[0].0.node().short_id();
entries.remove(0);
encoded.remove(0);
log::info!(
+2 -2
View File
@@ -91,7 +91,7 @@ pub fn sign_self_revocation(store: &Store) -> Result<RevocationRecord> {
let node_keypair = store.settings_store.load_keypair()?.ok_or(RetireError::NotInitialized)?;
let record = RevocationRecord::self_signed(&membership.delegation_cert, &node_keypair);
log::info!("This node signed its own revocation ({})", record.node_id_hex());
log::info!("This node signed its own revocation ({})", record.revoked_node().to_hex());
Ok(record)
}
@@ -136,7 +136,7 @@ pub fn revoke_peer(
&ensemble_keypair,
);
apply_locally(store, &record, &membership)?;
log::info!("Revoked node {} with the ensemble key", record.node_id_hex());
log::info!("Revoked node {} with the ensemble key", record.revoked_node().to_hex());
Ok(record)
}
+2 -2
View File
@@ -269,8 +269,8 @@ pub fn audience(store: &Store) -> Result<Vec<PeerLabel>> {
Ok(peers
.batch(|tx| peers.get_peer_nodes_for_ensemble(tx, &membership.ensemble_pubkey))?
.into_iter()
.filter(|p| local != Some(NodePubkey(p.node_pubkey)))
.map(|p| PeerLabel { node: NodePubkey(p.node_pubkey), display_name: p.display_name })
.filter(|p| local != Some(p.node()))
.map(|p| PeerLabel { node: p.node(), display_name: p.display_name })
.collect())
}
+5 -3
View File
@@ -58,6 +58,8 @@ use iroh::{PublicKey, Signature};
use serde::{Deserialize, Serialize};
use strum::{EnumString, IntoStaticStr};
use crate::node::NodePubkey;
use super::secret::{EnsembleSecret, Keypair, NodeSecret};
use super::{DelegationCert, EnsembleError, Fields, SignedRecord};
@@ -270,9 +272,9 @@ impl RevocationRecord {
self.revoked_cert_fingerprint == cert.fingerprint()
}
/// Hex-encoded pubkey of the revoked node (64 hex chars).
pub fn node_id_hex(&self) -> String {
hex::encode(self.revoked_node_pubkey)
/// The revoked node.
pub fn revoked_node(&self) -> NodePubkey {
NodePubkey(self.revoked_node_pubkey)
}
}
+4 -4
View File
@@ -226,7 +226,7 @@ pub fn build_ensemble_status(
let cert = &membership.delegation_cert;
let ensemble_pubkey = membership.ensemble_public_key()?.to_string();
let node_pubkey = cert.node_public_key()?.to_string();
let node_id_hex = cert.node_id_hex();
let node_id_hex = cert.node().to_hex();
let own_name = settings.as_ref().and_then(|s| s.node_name.clone());
let (node_name, node_name_is_placeholder) = node_display::resolve(own_name.as_deref());
// Timezone used to render the shared "last seen" timestamps below.
@@ -330,18 +330,18 @@ pub fn build_ensemble_status(
},
}
};
let this_pk = NodePubkey(cert.node_pubkey);
let this_pk = cert.node();
let mut seen = HashSet::from([this_pk]);
let mut members = vec![row(this_pk, own_name.as_deref(), None, None, true)];
for p in &peers {
let pk = NodePubkey(p.node_pubkey);
let pk = p.node();
if seen.insert(pk) {
let (seen_at, synced_at) = (Some(p.last_seen_at), p.last_synced_at);
members.push(row(pk, p.display_name.as_deref(), seen_at, synced_at, false));
}
}
for m in known_registry_members {
let pk = NodePubkey(m.node_pubkey);
let pk = m.node();
if seen.insert(pk) {
members.push(row(pk, None, None, None, false));
}
+1 -1
View File
@@ -284,7 +284,7 @@ impl DocumentsFfi {
};
for peer in peers {
let node = NodePubkey(peer.node_pubkey);
let node = peer.node();
if Some(node) == local {
continue;
}
+4 -4
View File
@@ -101,7 +101,7 @@ impl EnsembleFfi {
if peers.is_empty() {
return Err(SyncError::Offline { msg: "no peers available to sync from".into() });
}
Ok(peers.iter().map(|p| NodePubkey(p.node_pubkey)).collect())
Ok(peers.iter().map(|p| p.node()).collect())
}
/// Push a record to the ensemble's gossip topic, best-effort.
@@ -342,7 +342,7 @@ impl EnsembleFfi {
Ok(RevokedNodeInfo {
node_name: self.peer_name(&peer),
node_id_hex: record.node_id_hex(),
node_id_hex: record.revoked_node().to_hex(),
record_blob: record.to_blob(),
learned: true,
})
@@ -359,8 +359,8 @@ impl EnsembleFfi {
self.gossip_revocation(&record);
}
Ok(RevokedNodeInfo {
node_name: self.peer_name(&NodePubkey(record.revoked_node_pubkey)),
node_id_hex: record.node_id_hex(),
node_name: self.peer_name(&record.revoked_node()),
node_id_hex: record.revoked_node().to_hex(),
record_blob: record.to_blob(),
learned,
})
+1 -1
View File
@@ -341,7 +341,7 @@ fn verify(
});
}
Ok(CertifiedPeer { node: NodePubkey(cert.node_pubkey) })
Ok(CertifiedPeer { node: cert.node() })
}
/// Whether `cert` appears on this node's deny-list.
+1 -1
View File
@@ -887,7 +887,7 @@ pub async fn broadcast_revocation(
record: &RevocationRecord,
) -> Result<(), GossipError> {
broadcast(sender, &GossipMessage::Revocation(record.clone())).await?;
info!("Broadcast revocation for node {} to gossip topic", record.node_id_hex());
info!("Broadcast revocation for node {} to gossip topic", record.revoked_node().to_hex());
Ok(())
}
+1 -1
View File
@@ -226,7 +226,7 @@ pub(crate) fn apply_signed_membership(
continue;
}
applied.verified += 1;
let node = record.node_id_hex();
let node = record.revoked_node().to_hex();
let revoked_at =
believable_or_now(record.revoked_at_secs, format_args!("Revocation for {node}"));
if revocations.record_revocation(tx, record, revoked_at)? {
+4 -4
View File
@@ -265,7 +265,7 @@ pub async fn sync_with_peer(
else {
return Err(format!("{} is not a member of this node's ensemble", peer.to_hex()));
};
let label = peer_node.display_name.clone().unwrap_or_else(|| peer_node.node_short_id());
let label = peer_node.display_name.clone().unwrap_or_else(|| peer_node.node().short_id());
// `JobRunner`'s own dedup is in-memory, so it only sees what *this*
// runner started — and a store can have more than one runner over it (the
@@ -493,8 +493,8 @@ pub async fn run_catalog_pass(
if peer.node_pubkey == local_node.0 {
continue;
}
let node_pubkey = NodePubkey(peer.node_pubkey);
let label = peer.display_name.clone().unwrap_or_else(|| peer.node_short_id());
let node_pubkey = peer.node();
let label = peer.display_name.clone().unwrap_or_else(|| node_pubkey.short_id());
let Some(handle) = job_runner.start(
JobKind::CatalogSync,
@@ -800,7 +800,7 @@ pub(crate) fn peer_order_by_presence(
}
Ok(())
});
let mut targets: Vec<NodePubkey> = peers.iter().map(|p| NodePubkey(p.node_pubkey)).collect();
let mut targets: Vec<NodePubkey> = peers.iter().map(|p| p.node()).collect();
targets.sort_by_key(|pk| std::cmp::Reverse(counts.get(pk).copied().unwrap_or(0)));
targets
}
+4 -15
View File
@@ -34,6 +34,7 @@ use std::sync::Arc;
use tokio::sync::broadcast;
use crate::documents::Timestamp;
use crate::node::NodePubkey;
use crate::stores::change_bus::{ChangeChannel, ChangeLedger};
type Result<T> = std::result::Result<T, PeerNodeStoreError>;
@@ -75,14 +76,9 @@ pub struct PeerNode {
}
impl PeerNode {
/// Hex-encoded node public key (full 64-char iroh NodeId representation).
pub fn node_id_hex(&self) -> String {
hex::encode(self.node_pubkey)
}
/// Short hex identifier (first 8 hex chars / 4 bytes).
pub fn node_short_id(&self) -> String {
hex::encode(&self.node_pubkey[..4])
/// The peer node.
pub fn node(&self) -> NodePubkey {
NodePubkey(self.node_pubkey)
}
}
@@ -403,11 +399,4 @@ mod tests {
assert_eq!(bb_peers.len(), 1);
assert_eq!(bb_peers[0].node_pubkey, [0x02; 32]);
}
#[test]
fn short_id_and_hex() {
let p = peer_node(0xDE, 0xAA, None, None);
assert_eq!(p.node_short_id(), "dededede");
assert_eq!(p.node_id_hex().len(), 64);
}
}
+8 -8
View File
@@ -118,7 +118,7 @@ fn ensemble_members_snapshot(store: &Store) -> Result<EnsembleMembersSnapshot> {
);
};
let this_node_pubkey = NodePubkey(membership.delegation_cert.node_pubkey).to_hex();
let this_node_pubkey = membership.delegation_cert.node().to_hex();
let this_node_name = store
.settings_store
.batch(|tx| store.settings_store.load_settings(tx))
@@ -158,9 +158,9 @@ fn ensemble_members_snapshot(store: &Store) -> Result<EnsembleMembersSnapshot> {
})?
.into_iter()
.map(|peer| EnsembleMemberPeer {
revoked: revoked.contains(&peer.node_id_hex()),
health: health_by_node.remove(&NodePubkey(peer.node_pubkey)).unwrap_or_default(),
pubkey: peer.node_id_hex(),
revoked: revoked.contains(&peer.node().to_hex()),
health: health_by_node.remove(&peer.node()).unwrap_or_default(),
pubkey: peer.node().to_hex(),
name: peer.display_name,
last_seen_at: peer.last_seen_at,
})
@@ -1527,7 +1527,7 @@ fn revoke_peer_snapshot(store: &Store, id: &str, keyphrase: &str) -> Result<Revo
}
let record = retire::revoke_peer(store, &peer.0, keyphrase)?;
Ok(RevocationSnapshot {
node_id: record.node_id_hex(),
node_id: record.revoked_node().to_hex(),
node_name: revoked_node_name(store, &peer),
blob: record.to_blob(),
learned: true,
@@ -1541,9 +1541,9 @@ fn revoke_peer_snapshot(store: &Store, id: &str, keyphrase: &str) -> Result<Revo
/// gossip already delivered — worth saying, not worth failing.
fn import_revocation_snapshot(store: &Store, blob: &str) -> Result<RevocationSnapshot> {
let (record, learned) = retire::import_revocation(store, blob)?;
let peer = NodePubkey(record.revoked_node_pubkey);
let peer = record.revoked_node();
Ok(RevocationSnapshot {
node_id: record.node_id_hex(),
node_id: record.revoked_node().to_hex(),
node_name: revoked_node_name(store, &peer),
blob: record.to_blob(),
learned,
@@ -1720,7 +1720,7 @@ fn ensemble_peer_ids(store: &Store) -> Result<Vec<NodePubkey>> {
if peers.is_empty() {
anyhow::bail!("no peers available to sync from");
}
Ok(peers.iter().map(|p| NodePubkey(p.node_pubkey)).collect())
Ok(peers.iter().map(|p| p.node()).collect())
}
/// Pull **one** of a document's artifacts from ensemble peers — the narrow