Issue: Python libp2p Connect Method Requires PeerID While Other Implementations Don't

[acul71]

Issue: Python libp2p Connect Method Requires PeerID While Other Implementations Don't

Problem Description

The Python implementation of libp2p's connect method requires a PeerInfo object that includes a PeerID, which is not compliant with the libp2p specification. Other implementations like js-libp2p and rust-libp2p allow connections using just the network address (e.g., /ip4/127.0.0.1/tcp/8000).

Current Behavior

In the Python implementation, attempting to connect using just a network address results in an error because the connect method requires a PeerInfo object that must include a PeerID. This is evident from the implementation in libp2p/abc.py:

@abstractmethod
async def connect(self, peer_info: PeerInfo) -> None:
    """
    Establish a connection to the specified peer.
    ...
    Parameters
    ----------
    peer_info : PeerInfo
        The peer information of the peer to connect to.
    """

From peerinfo.py:

class PeerInfo:
    peer_id: ID
    addrs: list[multiaddr.Multiaddr]

    def __init__(self, peer_id: ID, addrs: Sequence[multiaddr.Multiaddr]) -> None:
        self.peer_id = peer_id
        self.addrs = list(addrs)

    def __eq__(self, other: Any) -> bool:
        return (
            isinstance(other, PeerInfo)
            and self.peer_id == other.peer_id
            and self.addrs == other.addrs
        )

Expected Behavior

In both Rust and JavaScript libp2p implementations, users can dial a peer using just a Multiaddr, without requiring a known PeerID. This allows greater flexibility, especially in discovery or NAT traversal scenarios.

• In rust-libp2p, methods like Swarm::dial accept plain Multiaddr values.
• In js-libp2p, libp2p.dial(multiaddr) works without embedding a /p2p/PeerID component.

The libp2p specification supports this approach, and issue #458 explicitly discusses the need to document and standardize dialing without a PeerID.

Impact

This strict requirement in Python:

1. Limits interoperability with peers whose PeerID is not yet known.
2. Prevents integration with libp2p systems built in Rust or JS.
3. Makes bootstrapping and dynamic discovery more difficult.
4. Forces unnecessary constraints on user applications.

Example

Current Python implementation requires:

maddr = multiaddr.Multiaddr("/ip4/127.0.0.1/tcp/8000")
info = info_from_p2p_addr(maddr)  # This fails without a PeerID
await host.connect(info)

listener.py

# Starts a host listening on /ip4/0.0.0.0/tcp/8000

import secrets

import multiaddr
import trio

from libp2p import (
    new_host,
)
from libp2p.crypto.secp256k1 import (
    create_new_key_pair,
)


async def main():
    # Create a key pair for the host
    secret = secrets.token_bytes(32)
    key_pair = create_new_key_pair(secret)

    # Create a host with the key pair
    host = new_host(key_pair=key_pair)

    # Configure the listening address
    port = 8000
    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")

    # Start the host
    async with host.run(listen_addrs=[listen_addr]):
        print("libp2p has started with TCP transport")
        print("libp2p is listening on:", host.get_addrs())
        # Keep the host running
        await trio.sleep_forever()


# Run the async function
trio.run(main)

dialer.py

# Attempts to connect to /ip4/127.0.0.1/tcp/8000
# Fails unless a PeerID is included in the address


import secrets

import multiaddr
import trio

from libp2p import (
    new_host,
)
from libp2p.crypto.secp256k1 import (
    create_new_key_pair,
)
from libp2p.peer.peerinfo import (
    info_from_p2p_addr,
)

async def main():
    # Create a key pair for the host
    secret = secrets.token_bytes(32)
    key_pair = create_new_key_pair(secret)

    # Create a host with the key pair
    host = new_host(key_pair=key_pair)

    # Configure the listening address
    port = 8001
    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")

    # Start the host
    async with host.run(listen_addrs=[listen_addr]):
        print("libp2p has started with TCP transport")
        print("libp2p is listening on:", host.get_addrs())
        # Keep the host running
        #await trio.sleep_forever()
        maddr = multiaddr.Multiaddr("/ip4/127.0.0.1/tcp/8000")
        info = info_from_p2p_addr(maddr)
        await host.connect(info)


# Run the async function
trio.run(main)

Proposed Solution

To align with other implementations and the intent of the libp2p spec:

1. Make PeerID optional: Refactor PeerInfo to allow omission of peer_id.
2. Support Multiaddr-only connections: Allow users to initiate connections from just a Multiaddr.
3. Resolve PeerID after connection: As done in rust/js, resolve the remote peer’s ID after connection handshake.
4. Preserve backward compatibility: Continue to support PeerInfo for advanced/manual connections.

References

• libp2p Specification
• js-libp2p Implementation
• rust-libp2p Implementation
• py-libp2p abc.py
• py-libp2p peerinfo.py

[acul71]

PeerID Requirement in libp2p Specification

Summary

The libp2p specification does not mandate that a PeerID must be known in advance to establish a connection. While PeerIDs are typically included in multiaddresses for identity verification, some implementations and spec discussions acknowledge valid use cases for connecting without one.

Specification Insights

The libp2p specifications acknowledge scenarios where dialing a peer without a known PeerID is valid. For example, libp2p/specs#458 discusses use cases such as:

• Connecting to a peer with a trusted IP and port combination without knowing its PeerID (e.g., in private networks).
• Dialing peers from DNS addresses, where PeerID may not be known ahead of time.

This illustrates that the libp2p spec allows for flexibility depending on context and trust models.

In addition, the libp2p HTTP Transport Gateway Specification notes:

“Peer ID Authentication over HTTP is optional and SHOULD NOT be required by Trustless Gateway HTTP endpoint defined for /ipfs/gateway handler.”

This supports the idea that PeerID is not universally required across all libp2p transports.

Implementation Examples

Some implementations explicitly support this:

• rust-libp2p: Allows dialing with just a Multiaddr. PeerID can be resolved during connection.
• nim-libp2p: Similarly supports address-only dialing.
• go-libp2p: Although it prefers PeerID-based dialing, it's possible to initiate a connection using an address alone and recover the PeerID from the connection handshake or error message.

Discussion: libp2p.io forum thread

Conclusion

While using PeerIDs enhances security and identity verification, libp2p does not strictly require a PeerID for establishing a connection. Both the specification and multiple implementations recognize and support scenarios where only a Multiaddr is used initially.

This behavior is useful for:

• Bootstrapping peers
• NAT traversal
• DNS-based discovery
• Private networks where identities are not pre-shared

[acul71]

@seetadev @pacrob @dhuseby
Please take a look at this issue and suggest how we should proceed

[pacrob]

Sounds good to me! I don't see any reason not to update to allow resolving PeerID after connection as you suggest.