From 41b2ba748531605a1afd84fdb967330c0efc529f Mon Sep 17 00:00:00 2001 From: Bitflash Date: Wed, 29 Jul 2026 14:11:58 -0300 Subject: net: exchange signed .btf descriptors between peers (#32) Discovery has depended entirely on the Nostr relays. Two connected nodes never told each other who else existed, so a relay outage left a running network unable to grow, and a node that found one stale peer had no way to learn there was anything better. The old `addr` gossip went out with the IRC seed. Peers now trade signed descriptors over a new "btfpeers" message: our own first, then peers that actually answered us. The receiver checks each Schnorr signature against the key the `.btf` address decodes to, so the sender is trusted for nothing -- forging an entry needs somebody else's secret key. That leaves flooding with self-generated keys, which the per-message caps and the "peers that answered" ordering are there to blunt. Unknown commands are ignored (main.cpp), so nodes without this just drop the message; nothing here is a protocol break. The cache from the peer-cache change now keeps each peer's descriptor verbatim alongside the parsed fields, because that signature is what makes a peer relayable. Entries without one -- resolved through Nostr, or written before this -- stay dialable, just not passed on. A dial never clears a descriptor already on file. --- src/nostr.cpp | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) (limited to 'src/nostr.cpp') diff --git a/src/nostr.cpp b/src/nostr.cpp index ec02c2e..482a835 100644 --- a/src/nostr.cpp +++ b/src/nostr.cpp @@ -342,6 +342,36 @@ std::string BtfLocalAddress() return g_nostrKey.BtfAddress(); } +// This node's own descriptor, signed and self-certifying -- the same blob +// PublishDescriptor puts on Nostr, but handed straight to a peer instead. +// +// Reads strBtfActiveRelay directly rather than going through BtfActiveRelay(): +// only a rendezvous we actually registered at is worth announcing. Handing out +// a meeting node we are not reachable at would make every peer that receives +// it burn a dial, and over peer exchange that mistake travels further than it +// does over Nostr. +std::string BtfLocalDescriptor() +{ + if (!EnsureNostrKey()) + return ""; + string meeting; + CRITICAL_BLOCK(cs_activeRelay) + meeting = strBtfActiveRelay; + if (meeting.empty()) + return ""; + return btf::SignDescriptor(g_nostrKey.ctx, g_nostrKey.seckey, + g_nostrKey.EncPubHex(), meeting, (uint64_t)GetTime()); +} + +// The shared secp256k1 context, so net.cpp can verify descriptors that arrive +// from peers. NULL if the identity could not be loaded. +void* BtfSecpContext() +{ + if (!EnsureNostrKey()) + return NULL; + return (void*)g_nostrKey.ctx; +} + int GetDiscoveredPeerCount() { int n = 0; -- cgit v1.2.3