subscribe_and_join() times out in local_discovery, but not discovery_n0

[guilherme-ds-matos]

Hello there,

I've been recently looking into projects for my Master's degree dissertation, and found p2p networks very interesting of a topic.
I decided to try, then, using iroh for some p2p networking and followed the examples Number 0 provided both in the repos as well as the website. I reached for this particular project, iroh-gossip, as a way to rapidly set up connections between two peers.

My project would leverage iroh-gossip for group-chat-like conversations. Granted, I understand iroh-gossip is better suited for single producer multiple consumer, but I wanted to try regardless; so I based it off n0's Chat example.

When I attempted using the n0 discovery service, it worked perfectly: my two machines would connect.

I then changed it to local-discovery, and, upon calling the function subscribe_and_join(), the program would hang, and after a while, the logs would indicate that the dialing failed with peer timed out, and it wouldn't try again.

I tried then, to adapt the local-discoveries and echo examples; my two machines connected using the echo protocol, with no hitch; not even a single timeout.

I wonder then, what does the iroh-gossip protocol do different that would make it so that, upon using a ticket and calling subscribe_and_join() on a local network, a connection times out? The connecting peer never quite seems to receive the address of the starting peer according to the logs. Would it be helpful if I pasted the logs here? They seem mostly to contain warnings about the Relay, more than anything.

[chrda81]

A possible solution: Pre-populate peer addresses to fix subscribe_and_join() timeout with local discovery

Problem Confirmation

I can confirm this issue affects iroh-gossip 0.94.0 when using local-only discovery (no n0 discovery service, no pkarr/DNS). The subscribe_and_join()
call times out because of a circular dependency in address resolution:

1. subscribe_and_join() internally calls Dialer::dial()
2. Dialer::dial() calls endpoint.connect(endpoint_id, alpn) with only an EndpointId (no socket addresses) - see net.rs:1020
3. endpoint.connect() relies on the Discovery system to resolve EndpointId → socket addresses
4. GossipDiscovery only learns addresses after receiving PeerData messages over an established connection (net.rs:730-742)
5. Catch-22: Can't connect without addresses, can't get addresses without connecting

Why It Works with n0 Discovery

The n0 discovery service breaks this cycle by providing peer addresses externally through DNS/pkarr, allowing endpoint.connect() to succeed before
gossip's internal GossipDiscovery gets populated.

Solution: Pre-populate with StaticProvider

Based on the test pattern in api.rs:466-469 and net.rs:1439-1441, the solution is to use StaticProvider to pre-populate peer addresses before calling
subscribe_and_join():

use iroh::discovery::static_provider::StaticProvider;

// 1. Create StaticProvider when initializing your endpoint
let static_provider = Arc::new(StaticProvider::new());

// 2. Add it to endpoint's discovery
endpoint.discovery().add(static_provider.clone());

// 3. Pre-populate peer addresses from your local discovery (mDNS, etc.)
// Do this BEFORE calling subscribe_and_join()
static_provider.add_endpoint_info(peer_endpoint_addr);

// 4. Now subscribe_and_join() will work because endpoint.connect() 
// can resolve addresses from StaticProvider
let topic = gossip.subscribe_and_join(topic_id, bootstrap_peers).await?;

Implementation Notes

• When to add addresses: Immediately when your local discovery (mDNS, manual config, etc.) discovers a peer
• What to add: The full EndpointAddr including both node_id and socket addresses
• Thread safety: StaticProvider is Arc-based and can be shared across threads

Verified Working

I've successfully implemented this solution in a React Native app using native mDNS discovery:

• iOS and Android devices discover each other via mDNS
• Addresses immediately added to StaticProvider
• subscribe_and_join() connects instantly (no timeout)
• Gossip messages flow correctly between peers

The key insight is that endpoint.connect() needs addresses available in the discovery system before the connection attempt, which GossipDiscovery alone
cannot provide in local-only scenarios.

Suggested Fix for iroh-gossip

Consider one of these approaches:

1. Document the requirement: Add to the README/docs that local-only discovery requires pre-populating peer addresses via StaticProvider
2. Accept EndpointAddr in subscribe_and_join: Change the API to accept Vec<EndpointAddr> instead of Vec<PublicKey> for bootstrap peers, and
   automatically add them to a local static provider
3. Add helper method: Provide a convenience method like:

impl Gossip {
    pub fn add_known_peer(&self, addr: EndpointAddr) {
        // Add to internal static provider
    }
}```