Struct TorRuntime 

pub struct TorRuntime { /* private fields */ }

Manages Tor connectivity for the Canon node.

Handles bootstrap, circuit pool management with warm circuits to peers, and an onion service for incoming search queries. The circuit pool targets CIRCUIT_POOL_SIZE warm connections with keepalive probes every KEEPALIVE_INTERVAL_SECS and rotation every CIRCUIT_ROTATION_SECS.

Implementations

impl TorRuntime

pub async fn bootstrap(config: TorConfig) -> Result<Self>

Bootstrap the Tor client and connect to the network.

This blocks until the Tor client is bootstrapped and connected, which typically takes under 1 minute on first launch. Returns when the client is ready for circuit establishment.

pub async fn state(&self) -> RuntimeState

Get the current runtime state.

pub async fn onion_address(&self) -> Option<String>

Get the node’s onion address (if the onion service is running).

pub async fn connect_to_peer(&self, onion_address: &str) -> Result<DataStream>

Open an anonymous Tor stream to a peer’s onion address.

Returns a DataStream that implements AsyncRead + AsyncWrite.

pub async fn build_registration(&self) -> PeerRegistration

Build a PeerRegistration for this node to publish on Arweave.

The onion_address is populated from the running onion service. Call start_onion_service before this to ensure the address is set.

pub async fn start_onion_service( &self, ) -> Result<BoxStream<'static, RendRequest>>

Launch the Tor onion service for incoming search queries.

Uses the arti TorClient::launch_onion_service API to create a real Tor hidden service. The service address is derived by arti from an auto-generated or stored keypair. Returns the stream of rendezvous requests that should be fed to run_accept_loop.

pub async fn run_accept_loop( self: &Arc<Self>, rend_requests: BoxStream<'static, RendRequest>, graph: Arc<Mutex<GraphStore>>, server_config: Arc<ServerConfig>, )

Run the incoming connection accept loop for the onion service.

Processes rendezvous requests from start_onion_service, accepts incoming streams, and spawns a handler for each connection. This runs until the runtime is shut down.

pub async fn run_circuit_maintenance( self: &Arc<Self>, peers: Arc<Mutex<Vec<PeerRegistration>>>, )

Run the circuit pool maintenance loop.

Manages warm circuits to peers: establishes DataStream connections to fill the pool, sends keepalive probes on held streams, and rotates circuits that have exceeded the rotation window. Runs until the runtime is shut down.

pub async fn shutdown(&self)

Initiate a graceful shutdown.