Struct IgcIrohNode 

pub struct IgcIrohNode { /* private fields */ }

Runtime handle for an igc-net node.

Holds the iroh endpoint, iroh-blobs filesystem store, gossip handler, and the local flat-file store.

Implementations

impl IgcIrohNode

pub async fn start(data_dir: impl Into<PathBuf>) -> Result<Self, NodeError>

Build and start a node rooted at data_dir.

• Loads or generates the Ed25519 key from data_dir/node.key.
• Initializes the separate pilot-keys/ directory for pilot identity custody; pilot keys remain distinct from the node transport key.
• Opens FlatFileStore at data_dir.
• Binds an iroh Endpoint, starts iroh-blobs and iroh-gossip.
• Subscribes to the announce gossip topic so remote peers can join the swarm immediately (HyParView state must exist for this to work).

pub async fn close(&self)

Gracefully shut down the node (closes endpoint and router).

pub fn node_id(&self) -> &NodeIdHex

The node’s stable network identity (hex-encoded Ed25519 public key).

pub fn iroh_node_id(&self) -> PublicKey

The node’s iroh PublicKey (EndpointId) — use this for gossip bootstrap when dialling the node directly via iroh.

pub fn endpoint_addr(&self) -> EndpointAddr

The node’s current EndpointAddr as reported by the iroh endpoint.

Right after start() this typically contains wildcard bind addresses (0.0.0.0:PORT) which are not dialable by remote peers. For loopback integration tests use [loopback_endpoint_addr] instead.

pub fn loopback_endpoint_addr(&self) -> Result<EndpointAddr, NodeError>

Build an EndpointAddr with a proper 127.0.0.1:PORT direct address.

Uses the actual bound UDP port from the endpoint and replaces the wildcard 0.0.0.0 bind address with the loopback interface. Pass the result to a peer’s [add_peer_addr] in integration tests so that gossip-bootstrap can dial over loopback without relay infrastructure.

pub fn loopback_addr_str(&self) -> Result<String, NodeError>

Return the node’s loopback endpoint as a "node_id@127.0.0.1:port" string.

Use this to populate a remote peer’s address book (via [add_peer_addr]) for direct loopback connections in tests and private networks that don’t rely on relay-based discovery.

pub fn add_peer_addr(&self, addr: EndpointAddr)

Pre-populate this node’s address book with a peer’s EndpointAddr.

After calling this, the node can dial the peer by its EndpointId alone (e.g., as a gossip bootstrap peer) using the known direct address instead of relay-based discovery.

pub async fn join_pilot_auth_did_gossip_peers( &self, peers: Vec<PublicKey>, ) -> Result<(), NodeError>

Join known peers on the pilot-auth-did governance gossip topic.

Call this after populating peer addresses for direct/private networks. Receiving a governance gossip announcement triggers a pull-sync against the delivering peer over the dedicated governance-sync transport.

pub async fn join_governance_gossip_peers( &self, peers: Vec<PublicKey>, ) -> Result<(), NodeError>

Join known peers on the normative governance gossip topic.

Call this after populating peer addresses for direct/private networks. Received records are validated, persisted idempotently, and then used by local governance state resolution.

pub async fn broadcast_governance_record<T: Serialize>( &self, record: &T, ) -> Result<(), NodeError>

Broadcast a full governance record on the normative governance topic.

Callers must persist the record locally before broadcasting so a local restart does not lose authority that was already advertised.

pub fn store(&self) -> &FlatFileStore

Access the local flat-file store.

pub fn generate_pilot_identity( &self, display_name: impl Into<String>, country: Option<String>, ) -> Result<PilotIdentity, NodeError>

Generate a new registered pilot identity in the multi-pilot key store.

pub async fn register_pilot_identity( &self, display_name: impl Into<String>, country: Option<String>, access_pin: &str, created_at: impl Into<String>, ) -> Result<PilotIdentity, NodeError>

Register a pilot with a local portal credential and publish its initial auth DID.

pub fn load_registered_pilot_identity( &self, pilot_id: &PilotId, ) -> Result<Option<PilotIdentity>, NodeError>

Load a registered pilot identity by stable pilot_id.

pub fn list_registered_pilots( &self, ) -> Result<Vec<PilotPublicIdentityWithProfile>, NodeError>

List registered pilots without exposing private key material.

pub fn load_registered_pilot_profile( &self, pilot_id: &PilotId, ) -> Result<Option<PilotProfile>, NodeError>

Load registered pilot profile metadata.

pub fn verify_pilot_credential( &self, pilot_id: &PilotId, access_pin: &str, ) -> Result<bool, NodeError>

Verify a registered pilot’s local portal credential.

pub fn registered_pilot_store(&self, pilot_id: &PilotId) -> PilotKeyStore

Return the per-pilot store used for pilot-auth-DID rotation.

pub async fn issue_initial_registered_pilot_auth_did_record( &self, pilot_id: &PilotId, created_at: impl Into<String>, ) -> Result<PilotAuthDidRecord, NodeError>

Create and persist the initial pilot-auth-did-record for a registered pilot.

pub async fn rotate_registered_pilot_auth_did( &self, pilot_id: &PilotId, created_at: impl Into<String>, ) -> Result<PilotAuthDidRecord, NodeError>

Rotate the active pilot_auth_did key for a registered pilot.

pub fn governance_store(&self) -> &GovernanceStore

Access the governance store that persists identity governance records.

pub fn resolve_pilot_auth_did_state( &self, pilot_id: &PilotId, ) -> Result<PilotAuthDidState, NodeError>

Resolve the current pilot-auth-DID state using local governance history.

pub fn prepare_pilot_auth_did_sync( &self, request: &PilotAuthDidSyncRequest, ) -> Result<PilotAuthDidSyncResponse, NodeError>

Build a pull-style catch-up response for a peer’s known pilot-auth-DID history.

pub fn build_pilot_auth_did_sync_request( &self, pilot_id: &PilotId, ) -> Result<PilotAuthDidSyncRequest, NodeError>

Build a pull-style catch-up request from the node’s full local pilot-auth-DID history.

pub fn apply_pilot_auth_did_sync( &self, response: &PilotAuthDidSyncResponse, ) -> Result<usize, NodeError>

Apply a pulled batch of pilot-auth-DID governance records to local storage.

pub async fn request_pilot_auth_did_sync_from_peer( &self, peer: PublicKey, request: &PilotAuthDidSyncRequest, ) -> Result<PilotAuthDidSyncResponse, NodeError>

Request a peer’s catch-up response over the governance-sync transport.

pub async fn sync_pilot_auth_did_from_peer( &self, peer: PublicKey, pilot_id: &PilotId, ) -> Result<usize, NodeError>

Pull pilot-auth-DID governance records for pilot_id from a peer and apply them locally.

pub fn resolve_path( &self, igc_hash: &str, ) -> Result<Option<PathBuf>, StoreError>

Resolve a local read-only filesystem path for a BLAKE3-keyed blob.

Returns Some(path) when the blob is present in the flat-file store. The caller may read the file directly in read-only mode; mutation must go through publish() or the store’s put() method.