Struct HashiverseServer 

pub struct HashiverseServer {

    pub runtime_services: Arc<RuntimeServices>,
    pub environment: Arc<Environment>,
    pub server_id: ServerId,
    pub kademlia: Arc<RwLock<Kademlia<Id, Peer>>>,
    pub transport_server: Arc<dyn TransportServer>,
    pub peer_self: Arc<RwLock<Peer>>,
    pub heal_in_progress: Cache<Id, ()>,
    pub seen_salts: Cache<Salt, ()>,
    pub post_bundle_cache: PostBundleCache,
    pub post_bundle_feedback_cache: PostBundleFeedbackCache,
    pub trending_hashtags: Cache<String, HyperLogLog>,
    pub trending_hashtags_response_cache: Mutex<Option<(TimeMillis, TrendingHashtagsFetchResponseV1)>>,
    pub request_counters: Arc<[AtomicU64; 17]>,
    pub peer_stats_response_cache: Mutex<Option<(TimeMillis, PeerStatsResponseV1)>>,
}

Fields

runtime_services: Arc<RuntimeServices>

environment: Arc<Environment>

server_id: ServerId

kademlia: Arc<RwLock<Kademlia<Id, Peer>>>

transport_server: Arc<dyn TransportServer>

peer_self: Arc<RwLock<Peer>>

heal_in_progress: Cache<Id, ()>

seen_salts: Cache<Salt, ()>

post_bundle_cache: PostBundleCache

post_bundle_feedback_cache: PostBundleFeedbackCache

trending_hashtags: Cache<String, HyperLogLog>

trending_hashtags_response_cache: Mutex<Option<(TimeMillis, TrendingHashtagsFetchResponseV1)>>

request_counters: Arc<[AtomicU64; 17]>

Per-PayloadRequestKind running counter of inbound dispatches. Incremented after packet decode + replay-guard but before per-handler PoW gates, so adversarial load shows up too.

peer_stats_response_cache: Mutex<Option<(TimeMillis, PeerStatsResponseV1)>>

Cached signed stats blob. The TimeMillis is the timestamp recorded in the cached PeerStatsResponseV1 itself — the cache hands the response back verbatim so clients re-sharing it get a single canonical byte sequence.

Implementations

impl HashiverseServer

pub async fn wrap_and_dispatch_network_envelopes( &self, cancellation_token: CancellationToken, rx: Receiver<IncomingRequest>, ) -> Result<(), Error>

impl HashiverseServer

pub async fn new( runtime_services: Arc<RuntimeServices>, environment_factory: Arc<dyn EnvironmentFactory>, args: Args, ) -> Result<Arc<Self>>

pub async fn run(&self, cancellation_token: CancellationToken)

pub async fn add_potential_peer_to_kademlia( &self, peer: Peer, time_millis: TimeMillis, )