use std::collections::{BTreeMap, HashMap, HashSet};
use std::net::SocketAddr;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::net::UdpSocket;
use tokio::sync::{oneshot, RwLock};
use tokio::time::timeout;
use crate::bencode::BencodeValue;
use crate::config::{BootstrapNode, Config};
use crate::dht::bootstrap::resolve_bootstrap;
use crate::dht::codec::{decode_message, encode_query, encode_response};
use crate::dht::messages::{
decode_nodes_auto, decode_peer_values, decode_peers_auto, DhtMethod, DhtQuery, DhtResponse,
};
use crate::dht::node_id::NodeId;
use crate::dht::routing::{NodeEntry, RoutingTable};
use crate::dht::token::AnnounceTokenTable;
use crate::error::{Error, Result};
use crate::net::{DialGate, PendingMap, ReplyBudget, UdpRateLimit};
#[derive(Debug)]
struct GetPeersResult {
peers: Vec<SocketAddr>,
nodes: Vec<NodeEntry>,
token: Option<Vec<u8>>,
}
const DHT_QUERY_RATE_PER_IP: u32 = 32;
const DHT_REPLY_MAX_PEERS: usize = 8;
const DHT_REPLY_MAX_NODES: usize = 8;
const DHT_PEER_STORE_MAX_PER_SWARM: usize = 256;
const DHT_PEERS_PER_RESPONDER: usize = 8;
const DHT_MAINTENANCE_INTERVAL: Duration = Duration::from_secs(60);
const DHT_STALE_CONTACT: Duration = Duration::from_secs(900);
type PeerAnnounceStore = HashMap<[u8; 20], HashMap<SocketAddr, Instant>>;
pub struct DhtNode {
socket: Arc<UdpSocket>,
table: Arc<RwLock<RoutingTable>>,
pending: Arc<RwLock<PendingMap<DhtResponse>>>,
swarms: Arc<RwLock<HashSet<[u8; 20]>>>,
peer_store: Arc<RwLock<PeerAnnounceStore>>,
tokens: Arc<RwLock<AnnounceTokenTable>>,
dial_gate: DialGate,
query_limit: Arc<tokio::sync::Mutex<UdpRateLimit>>,
reply_budget: Arc<tokio::sync::Mutex<ReplyBudget>>,
bootstrap: Vec<BootstrapNode>,
peer_announce_ttl: Duration,
}
impl DhtNode {
pub async fn bind(cfg: &Config) -> Result<Self> {
let socket = crate::net::bind_udp(cfg.listen_port, cfg.listen_dual_stack).await?;
let dial_gate = DialGate::from_block_private(cfg.tracker_block_private);
let peer_announce_ttl = Duration::from_secs(cfg.dht_peer_announce_ttl_secs.max(60));
let mut local_id = NodeId::random();
let mut contacts = Vec::new();
if cfg.dht_persist {
let path = crate::dht::default_persist_path(cfg);
let integrity = dht_persist_integrity(cfg)?;
match crate::dht::load_routing_snapshot(cfg, &integrity) {
Ok((saved_id, saved_contacts)) => {
if let Some(id) = saved_id {
local_id = id;
tracing::info!(
path = %path.display(),
"restored stable dht node id from snapshot"
);
}
contacts = saved_contacts;
}
Err(err) => {
tracing::warn!(
%err,
path = %path.display(),
"failed to load dht routing snapshot"
);
}
}
}
let mut table = RoutingTable::new(local_id);
let mut loaded = 0usize;
for (id, addr) in contacts {
if !dial_gate.allows(addr) {
continue;
}
table.upsert(NodeEntry::new(id, addr));
loaded += 1;
}
if loaded > 0 {
tracing::info!(count = loaded, "loaded dht routing contacts");
}
Ok(Self {
socket: Arc::new(socket),
table: Arc::new(RwLock::new(table)),
pending: Arc::new(RwLock::new(PendingMap::new())),
swarms: Arc::new(RwLock::new(HashSet::new())),
peer_store: Arc::new(RwLock::new(HashMap::new())),
tokens: Arc::new(RwLock::new(AnnounceTokenTable::random())),
dial_gate,
query_limit: Arc::new(tokio::sync::Mutex::new(UdpRateLimit::new(
DHT_QUERY_RATE_PER_IP,
))),
reply_budget: Arc::new(tokio::sync::Mutex::new(ReplyBudget::new())),
bootstrap: cfg.dht_bootstrap.clone(),
peer_announce_ttl,
})
}
pub async fn persist_routing_table(&self, cfg: &Config) -> Result<()> {
if !cfg.dht_persist {
return Ok(());
}
let table = self.table.read().await;
let integrity = dht_persist_integrity(cfg)?;
crate::dht::save_routing_table(cfg, &table, &integrity)
}
pub async fn routing_table_size(&self) -> usize {
self.table.read().await.live_node_count()
}
pub async fn register_swarm(&self, info_hash: &[u8; 20]) {
self.swarms.write().await.insert(*info_hash);
}
pub async fn unregister_swarm(&self, info_hash: &[u8; 20]) {
self.swarms.write().await.remove(info_hash);
self.peer_store.write().await.remove(info_hash);
}
pub async fn note_peers(&self, info_hash: &[u8; 20], peers: &[SocketAddr]) {
let peers = self.dial_gate.filter(peers.iter().copied());
if peers.is_empty() {
return;
}
let now = Instant::now();
let mut store = self.peer_store.write().await;
let entry = store.entry(*info_hash).or_default();
for peer in peers {
if entry.len() >= DHT_PEER_STORE_MAX_PER_SWARM && !entry.contains_key(&peer) {
break;
}
entry.insert(peer, now);
}
}
pub async fn bootstrap(&self, extra: &[SocketAddr]) -> Result<()> {
let mut targets = self.dial_gate.filter(resolve_bootstrap(&self.bootstrap));
targets.extend(self.dial_gate.filter(extra.iter().copied()));
targets.sort_by_key(|a| a.is_ipv6());
targets.dedup();
for addr in targets {
if let Err(err) = self.ping(addr).await {
tracing::debug!(%err, %addr, "dht bootstrap ping failed");
}
if !self.table.read().await.all_entries().is_empty() {
break;
}
}
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
let mut backoff = Duration::from_millis(50);
while tokio::time::Instant::now() < deadline {
if !self.table.read().await.all_entries().is_empty() {
break;
}
tokio::time::sleep(backoff).await;
backoff = (backoff * 2).min(Duration::from_millis(400));
}
let local = self.table.read().await.local_id();
if let Err(err) = self.find_node_iterative(local).await {
tracing::debug!(%err, "dht bootstrap find_node(self) failed");
}
Ok(())
}
pub async fn run_maintenance(self: Arc<Self>) {
let mut interval = tokio::time::interval(DHT_MAINTENANCE_INTERVAL);
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
interval.tick().await;
self.prune_expired_peers().await;
self.refresh_stale_contacts().await;
}
}
async fn prune_expired_peers(&self) {
let ttl = self.peer_announce_ttl;
let now = Instant::now();
let mut store = self.peer_store.write().await;
store.retain(|_, peers| {
peers.retain(|_, seen| now.duration_since(*seen) <= ttl);
!peers.is_empty()
});
}
async fn refresh_stale_contacts(&self) {
let stale = self
.table
.read()
.await
.stale_contacts(DHT_STALE_CONTACT, 8);
for entry in stale {
match self.ping(entry.addr).await {
Ok(()) => {}
Err(err) => {
tracing::debug!(%err, addr = %entry.addr, "dht stale ping failed; dropping");
self.table.write().await.remove_id(&entry.id);
}
}
}
let local = self.table.read().await.local_id();
if let Err(err) = self.find_node_iterative(local).await {
tracing::debug!(%err, "dht maintenance find_node(self) failed");
}
let refresh_buckets = self
.table
.read()
.await
.buckets_needing_refresh(DHT_STALE_CONTACT, 4);
for bucket_idx in refresh_buckets {
let target = self.table.read().await.refresh_target(bucket_idx);
if let Err(err) = self.find_node_iterative(target).await {
tracing::debug!(%err, bucket_idx, "dht bucket refresh find_node failed");
}
}
}
pub async fn get_peers(&self, info_hash: &[u8; 20]) -> Result<Vec<SocketAddr>> {
let target = NodeId::from_info_hash(info_hash);
self.find_node_iterative(target).await?;
let mut peers = HashSet::new();
let mut queried = HashSet::new();
for _ in 0..4 {
let closest = self.table.read().await.closest(&target, 8);
if closest.is_empty() {
break;
}
for node in closest {
if !queried.insert(node.addr) {
continue;
}
match self
.query_get_peers(node.addr, info_hash, Duration::from_secs(3))
.await
{
Ok(result) => {
let accepted: Vec<_> = self
.dial_gate
.filter(result.peers.iter().copied())
.into_iter()
.take(DHT_PEERS_PER_RESPONDER)
.collect();
self.note_peers(info_hash, &accepted).await;
peers.extend(accepted);
for entry in result.nodes {
self.upsert_contact(entry).await;
}
}
Err(err) => tracing::debug!(%err, addr = %node.addr, "get_peers query failed"),
}
}
if !peers.is_empty() {
break;
}
}
if peers.is_empty() {
return Err(Error::Dht("no peers found via DHT".into()));
}
let mut out: Vec<_> = peers.into_iter().collect();
out.sort();
Ok(out)
}
pub async fn announce_peer(&self, info_hash: &[u8; 20], port: u16) -> Result<()> {
let target = NodeId::from_info_hash(info_hash);
let closest = self.find_node_iterative(target).await?;
let local_id = self.table.read().await.local_id();
for node in closest.into_iter().take(3) {
let result = match self
.query_get_peers(node.addr, info_hash, Duration::from_secs(3))
.await
{
Ok(result) => result,
Err(err) => {
tracing::debug!(%err, addr = %node.addr, "announce_peer get_peers failed");
continue;
}
};
let Some(token) = result.token else {
continue;
};
let mut args = query_args(local_id);
args.insert(
b"info_hash".to_vec(),
BencodeValue::Bytes(info_hash.to_vec()),
);
args.insert(b"port".to_vec(), BencodeValue::Int(port as i64));
args.insert(b"token".to_vec(), BencodeValue::Bytes(token));
let query = DhtQuery {
transaction_id: dht_tx_id()?,
method: DhtMethod::AnnouncePeer,
arguments: args,
};
if let Err(err) = self
.socket
.send_to(&encode_query(&query), node.addr)
.await
{
tracing::debug!(%err, addr = %node.addr, "announce_peer send failed");
}
}
Ok(())
}
pub async fn run(self: Arc<Self>) -> Result<()> {
crate::ingress!("dht_udp");
let mut buf = vec![0u8; crate::security::MAX_DHT_DATAGRAM];
let mut packets = 0u64;
loop {
let (len, addr) = self
.socket
.recv_from(&mut buf)
.await
.map_err(Error::from)?;
if len > crate::security::MAX_DHT_DATAGRAM {
continue;
}
let addr = crate::net::normalize_socket_addr(addr);
{
let mut limit = self.query_limit.lock().await;
if !limit.allow(addr.ip()) {
continue;
}
packets = packets.saturating_add(1);
if packets.is_multiple_of(256) {
limit.prune();
self.reply_budget.lock().await.prune();
}
}
let Ok(message) = decode_message(&buf[..len]) else {
continue;
};
if let Err(err) = self.handle_message(message, addr).await {
tracing::debug!(%err, %addr, "dht handle_message failed");
}
}
}
async fn find_node_iterative(&self, target: NodeId) -> Result<Vec<NodeEntry>> {
let mut queried = HashSet::new();
for _ in 0..6 {
let closest = self.table.read().await.closest(&target, 8);
if closest.is_empty() {
break;
}
let mut improved = false;
for node in closest {
if !queried.insert(node.addr) {
continue;
}
match self
.query_find_node(node.addr, target, Duration::from_secs(2))
.await
{
Ok(nodes) => {
for entry in nodes {
self.upsert_contact(entry).await;
improved = true;
}
}
Err(err) => tracing::debug!(%err, addr = %node.addr, "find_node failed"),
}
}
if !improved {
break;
}
}
Ok(self.table.read().await.closest(&target, 8))
}
async fn ping(&self, addr: SocketAddr) -> Result<()> {
if !self.dial_gate.allows(addr) {
return Ok(());
}
let local_id = self.table.read().await.local_id();
let tx_id = dht_tx_id()?;
let (reply_tx, reply_rx) = oneshot::channel();
self.pending
.write()
.await
.try_insert(addr, tx_id.clone(), reply_tx)?;
let query = DhtQuery {
transaction_id: tx_id.clone(),
method: DhtMethod::Ping,
arguments: query_args(local_id),
};
if let Err(err) = self.socket.send_to(&encode_query(&query), addr).await {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::from(err));
}
let response = match timeout(Duration::from_secs(2), reply_rx).await {
Ok(Ok(Ok(response))) => response,
Ok(Ok(Err(err))) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(err);
}
Ok(Err(_)) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht("dht ping response channel closed".into()));
}
Err(_) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht(format!("ping timed out for {addr}")));
}
};
let _ = response;
Ok(())
}
async fn query_find_node(
&self,
addr: SocketAddr,
target: NodeId,
wait: Duration,
) -> Result<Vec<NodeEntry>> {
let local_id = self.table.read().await.local_id();
let tx_id = dht_tx_id()?;
let (reply_tx, reply_rx) = oneshot::channel();
self.pending
.write()
.await
.try_insert(addr, tx_id.clone(), reply_tx)?;
let mut args = query_args(local_id);
args.insert(
b"target".to_vec(),
BencodeValue::Bytes(target.as_bytes().to_vec()),
);
let query = DhtQuery {
transaction_id: tx_id.clone(),
method: DhtMethod::FindNode,
arguments: args,
};
if let Err(err) = self.socket.send_to(&encode_query(&query), addr).await {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::from(err));
}
let response = match timeout(wait, reply_rx).await {
Ok(Ok(Ok(response))) => response,
Ok(Ok(Err(err))) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(err);
}
Ok(Err(_)) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht("dht response channel closed".into()));
}
Err(_) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht(format!("find_node timed out for {addr}")));
}
};
Ok(parse_nodes_response(&response))
}
async fn query_get_peers(
&self,
addr: SocketAddr,
info_hash: &[u8; 20],
wait: Duration,
) -> Result<GetPeersResult> {
let local_id = self.table.read().await.local_id();
let tx_id = dht_tx_id()?;
let (reply_tx, reply_rx) = oneshot::channel();
self.pending
.write()
.await
.try_insert(addr, tx_id.clone(), reply_tx)?;
let mut args = query_args(local_id);
args.insert(
b"info_hash".to_vec(),
BencodeValue::Bytes(info_hash.to_vec()),
);
let query = DhtQuery {
transaction_id: tx_id.clone(),
method: DhtMethod::GetPeers,
arguments: args,
};
if let Err(err) = self.socket.send_to(&encode_query(&query), addr).await {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::from(err));
}
let response = match timeout(wait, reply_rx).await {
Ok(Ok(Ok(response))) => response,
Ok(Ok(Err(err))) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(err);
}
Ok(Err(_)) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht("dht response channel closed".into()));
}
Err(_) => {
self.pending.write().await.cancel(addr, &tx_id);
return Err(Error::Dht(format!("get_peers timed out for {addr}")));
}
};
Ok(parse_get_peers_response(&response))
}
async fn handle_message(
&self,
message: crate::dht::messages::DhtMessage,
addr: SocketAddr,
) -> Result<()> {
match message {
crate::dht::messages::DhtMessage::Response(response) => {
let matched = self.pending.write().await.complete(
addr,
&response.transaction_id,
response.clone(),
);
if matched {
self.ingest_node(&response, addr).await;
for entry in parse_nodes_from_response(&response) {
self.upsert_contact(entry).await;
}
}
}
crate::dht::messages::DhtMessage::Query(query) => {
if let Err(err) = self.respond_to_query(query, addr).await {
tracing::debug!(%err, %addr, "dht respond_to_query failed");
}
}
}
Ok(())
}
async fn upsert_contact(&self, entry: NodeEntry) {
if self.dial_gate.allows(entry.addr) {
self.table.write().await.upsert(entry);
}
}
async fn ingest_node(&self, response: &DhtResponse, addr: SocketAddr) {
if let Some(id_bytes) = response.values.get(b"id".as_ref()).and_then(|v| v.as_bytes()) {
if id_bytes.len() == 20 {
let mut id = [0u8; 20];
id.copy_from_slice(id_bytes);
self.upsert_contact(NodeEntry::new(NodeId::from_bytes(id), addr))
.await;
}
}
}
async fn respond_to_query(&self, query: DhtQuery, addr: SocketAddr) -> Result<()> {
let local_id = self.table.read().await.local_id();
let mut values = BTreeMap::from([(
b"id".to_vec(),
BencodeValue::Bytes(local_id.as_bytes().to_vec()),
)]);
match query.method {
DhtMethod::FindNode => {
let target_bytes = query
.arguments
.get(b"target".as_ref())
.and_then(|v| v.as_bytes())
.ok_or_else(|| Error::Dht("find_node missing target".into()))?;
if target_bytes.len() != 20 {
return Err(Error::Dht("find_node target must be 20 bytes".into()));
}
let mut target = [0u8; 20];
target.copy_from_slice(target_bytes);
let closest = self
.table
.read()
.await
.closest(&NodeId::from_bytes(target), DHT_REPLY_MAX_NODES);
insert_nodes_replies(&mut values, &closest);
}
DhtMethod::GetPeers => {
let token = self.tokens.write().await.issue(addr);
values.insert(b"token".to_vec(), BencodeValue::Bytes(token));
let mut served_values = false;
if let Some(hash_bytes) = query
.arguments
.get(b"info_hash".as_ref())
.and_then(|v| v.as_bytes())
{
if hash_bytes.len() == 20 {
let mut info_hash = [0u8; 20];
info_hash.copy_from_slice(hash_bytes);
let registered = self.swarms.read().await.contains(&info_hash);
if registered {
let store = self.peer_store.read().await;
let peers = live_peers_from_store(
&store,
&info_hash,
self.peer_announce_ttl,
);
let peers: Vec<_> =
peers.into_iter().take(DHT_REPLY_MAX_PEERS).collect();
drop(store);
if let Some(list) =
crate::wire::encode_peer_values_list(&peers, false)
{
values.insert(b"values".to_vec(), list);
served_values = true;
}
if let Some(list) =
crate::wire::encode_peer_values_list(&peers, true)
{
values.insert(b"values6".to_vec(), list);
served_values = true;
}
}
if !served_values {
let closest = self
.table
.read()
.await
.closest(&NodeId::from_info_hash(&info_hash), DHT_REPLY_MAX_NODES);
insert_nodes_replies(&mut values, &closest);
}
}
}
}
DhtMethod::AnnouncePeer => {
if let Err(err) = self.process_announce_peer(&query, addr).await {
tracing::debug!(%err, %addr, "dht announce_peer rejected");
}
}
DhtMethod::Ping => {}
}
let response = DhtResponse {
transaction_id: query.transaction_id,
values,
};
let encoded = encode_response(&response);
{
let mut budget = self.reply_budget.lock().await;
if !budget.allow_reply(addr, encoded.len()) {
tracing::debug!(%addr, bytes = encoded.len(), "dht reply budget exhausted");
return Ok(());
}
}
self.socket
.send_to(&encoded, addr)
.await
.map_err(Error::from)
.map(|_| ())
}
async fn process_announce_peer(&self, query: &DhtQuery, addr: SocketAddr) -> Result<()> {
let token = query
.arguments
.get(b"token".as_ref())
.and_then(|v| v.as_bytes())
.ok_or_else(|| Error::Dht("announce_peer missing token".into()))?;
if !self.tokens.write().await.verify(addr, token) {
return Err(Error::Dht("announce_peer invalid token".into()));
}
let implied_port = query
.arguments
.get(b"implied_port".as_ref())
.and_then(|v| v.as_int())
.unwrap_or(0);
let peer_port = if implied_port != 0 {
addr.port()
} else {
let port = query
.arguments
.get(b"port".as_ref())
.and_then(|v| v.as_int())
.ok_or_else(|| Error::Dht("announce_peer missing port".into()))?;
if !(1..=65535).contains(&port) {
return Err(Error::Dht("announce_peer port out of range".into()));
}
port as u16
};
if peer_port == 0 {
return Err(Error::Dht("announce_peer port out of range".into()));
}
let hash_bytes = query
.arguments
.get(b"info_hash".as_ref())
.and_then(|v| v.as_bytes())
.ok_or_else(|| Error::Dht("announce_peer missing info_hash".into()))?;
if hash_bytes.len() != 20 {
return Err(Error::Dht("announce_peer info_hash must be 20 bytes".into()));
}
let mut info_hash = [0u8; 20];
info_hash.copy_from_slice(hash_bytes);
if !self.swarms.read().await.contains(&info_hash) {
return Err(Error::Dht(
"announce_peer rejected for unregistered swarm".into(),
));
}
let peer_addr = SocketAddr::new(addr.ip(), peer_port);
self.note_peers(&info_hash, &[peer_addr]).await;
Ok(())
}
}
fn live_peers_from_store(
store: &PeerAnnounceStore,
info_hash: &[u8; 20],
ttl: Duration,
) -> Vec<SocketAddr> {
let now = Instant::now();
let Some(peers) = store.get(info_hash) else {
return Vec::new();
};
let mut live: Vec<_> = peers
.iter()
.filter(|(_, seen)| now.duration_since(**seen) <= ttl)
.map(|(addr, _)| *addr)
.collect();
live.sort();
live
}
fn parse_get_peers_response(response: &DhtResponse) -> GetPeersResult {
let mut peers = Vec::new();
for key in [b"values".as_ref(), b"values6".as_ref()] {
if let Some(values) = response.values.get(key) {
peers.extend(decode_peer_values(values));
if let Some(raw) = values.as_bytes() {
peers.extend(decode_peers_auto(raw));
}
}
}
let nodes = parse_nodes_from_response(response);
let token = response
.values
.get(b"token".as_ref())
.and_then(|v| v.as_bytes())
.map(|b| b.to_vec());
peers.sort();
peers.dedup();
GetPeersResult { peers, nodes, token }
}
fn parse_nodes_response(response: &DhtResponse) -> Vec<NodeEntry> {
parse_nodes_from_response(response)
}
fn parse_nodes_from_response(response: &DhtResponse) -> Vec<NodeEntry> {
let mut nodes = Vec::new();
for key in [b"nodes".as_ref(), b"nodes6".as_ref()] {
if let Some(raw) = response.values.get(key).and_then(|v| v.as_bytes()) {
for node in decode_nodes_auto(raw) {
nodes.push(NodeEntry::new(NodeId::from_bytes(node.id), node.addr));
}
}
}
nodes
}
fn insert_nodes_replies(
values: &mut BTreeMap<Vec<u8>, BencodeValue>,
closest: &[NodeEntry],
) {
let compact: Vec<_> = closest
.iter()
.map(|node| crate::wire::CompactNode {
id: *node.id.as_bytes(),
addr: node.addr,
})
.collect();
let v4 = crate::wire::encode_nodes(&compact, false);
let v6 = crate::wire::encode_nodes(&compact, true);
if !v4.is_empty() {
values.insert(b"nodes".to_vec(), BencodeValue::Bytes(v4));
}
if !v6.is_empty() {
values.insert(b"nodes6".to_vec(), BencodeValue::Bytes(v6));
}
}
fn query_args(id: NodeId) -> BTreeMap<Vec<u8>, BencodeValue> {
BTreeMap::from([(
b"id".to_vec(),
BencodeValue::Bytes(id.as_bytes().to_vec()),
)])
}
fn dht_persist_integrity(cfg: &Config) -> Result<crate::integrity::IntegrityConfig> {
crate::integrity::host_state_integrity(cfg).map_err(|err| {
Error::Dht(format!(
"DHT routing persist requires host integrity (refusing public-MAC fallback): {err}"
))
})
}
fn dht_tx_id() -> Result<Vec<u8>> {
Ok(crate::net::random_bytes::<2>()?.to_vec())
}