Struct DhtConfig 

pub struct DhtConfig {
    pub k: usize,
    pub alpha: usize,
    pub provider_ttl: Duration,
    pub republish_interval: Duration,
    pub refresh_interval: Duration,
    pub rpc_timeout: Duration,
    pub provider_store_limits: ProviderStoreLimits,
    pub discovery_cache_ttl: Duration,
    pub discovery_cache_limits: ProviderStoreLimits,
}

Kademlia parameters for a DhtService.

The defaults follow the canonical Kademlia paper (k = 20, α = 3) and typical provider-record lifetimes; every field is documented so a node operator can tune replication vs. traffic.

Fields

k: usize

Replication parameter k — the bucket size and the number of closest peers a lookup converges on. A provider record is announced to (and a find_node returns) up to k peers. Larger k = more redundancy against churn, more traffic. Canonical default: 20.

alpha: usize

Lookup parallelism α — how many peers an iterative lookup queries concurrently per round. Larger α = faster convergence, more in-flight traffic. Canonical default: 3.

provider_ttl: Duration

Provider-record TTL — how long a PUT provider record is considered valid. A holder republishes before this elapses; a finder discards records older than this. Default: 2 hours.

This is also the clamp ceiling for inbound add_provider records (SPEC §6.2, §14): a responder never stores a third-party expires_at further in the future than now + provider_ttl, so a malicious record can never outlive local GC indefinitely.

republish_interval: Duration

Republish interval — how often the holder re-announces the content it still holds, so its provider records never expire while it is online. MUST be shorter than Self::provider_ttl. Default: 1 hour.

refresh_interval: Duration

Bucket-refresh interval — how often a bucket with no recent activity is refreshed by looking up a random key that falls in it, keeping the routing table populated. Default: 1 hour.

rpc_timeout: Duration

Per-RPC timeout — how long a single request to one peer may take before that peer is treated as unresponsive and the lookup moves on. Default: 5 seconds.

provider_store_limits: ProviderStoreLimits

Provider-store admission-control caps — the per-content-key and global record limits enforced on every inbound add_provider (SPEC §6.3, §14). Bounds worst-case memory growth from a single peer (or a small set of colluding peers) flooding announces. Default: ProviderStoreLimits::default.

discovery_cache_ttl: Duration

Discovery-cache TTL — how long a provider record LEARNED FROM THIS NODE’S OWN LOOKUP is kept so a later fetch of the same content can dial directly instead of walking the DHT again (SPEC §6.8). Default: 15 minutes.

Deliberately far shorter than Self::provider_ttl, for a reason specific to this cache: nothing republishes into it. An authoritative record survives 2 hours because its holder refreshes it on Self::republish_interval; a cached one has no such keeper, so its age is pure guesswork about a holder this node has not spoken to since. 15 minutes spans a whole multi-range download of one store and the re-reads that immediately follow it — where the saving actually accrues — while keeping a holder that dropped the content (an LRU eviction upstream takes minutes, not hours) from being dialed for the rest of the afternoon.

It is a CLAMP, never an extension: a cached record expires at min(record.expires_at, now + discovery_cache_ttl), so a peer cannot lengthen its own residence in this node’s cache by claiming a distant expiry.

discovery_cache_limits: ProviderStoreLimits

Discovery-cache caps — the per-content-key and global record limits enforced on the cache (SPEC §6.8), by the same ProviderStore admission control the authoritative store uses.

Tighter than Self::provider_store_limits on both axes, because the cache answers a narrower question. Per key it holds 8 — a caller dials a handful of candidates and gives up, so a ninth is memory spent on a dial nobody will make, and it matches the MAX_ADDRESSES_PER_RECORD disclosure budget the node’s redirect path already settled on. Globally it holds 10 000 keys’ worth: the cache is keyed by what THIS node went looking for, which is bounded by its own fetch behaviour rather than by strangers’ announces, so the authoritative store’s 100 000-record ceiling would buy nothing but a larger footprint for a pathological workload to fill.

Implementations

impl DhtConfig

pub fn provider_ttl_secs(&self) -> u64

The provider TTL in whole seconds (records store an absolute Unix-seconds expiry).

pub fn discovery_cache_ttl_secs(&self) -> u64

The discovery-cache TTL in whole seconds (the cache stores absolute Unix-seconds expiries).

Trait Implementations

impl Clone for DhtConfig

fn clone(&self) -> DhtConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DhtConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DhtConfig

fn default() -> Self

Returns the “default value” for a type.