Merge pull request #626 from sukhman-sukh/limit_concurrency

Limit concurrency to push identify message to peers

docs/examples.mDNS.rst

@@ -0,0 +1,64 @@
+mDNS Peer Discovery Example
+===========================
+
+This example demonstrates how to use mDNS (Multicast DNS) for peer discovery in py-libp2p.
+
+Prerequisites
+-------------
+
+First, ensure you have py-libp2p installed and your environment is activated:
+
+.. code-block:: console
+
+    $ python -m pip install libp2p
+
+Running the Example
+-------------------
+
+The mDNS demo script allows you to discover peers on your local network using mDNS. To start a peer, run:
+
+.. code-block:: console
+
+    $ mdns-demo
+
+You should see output similar to:
+
+.. code-block:: console
+
+    Run this from another console to start another peer on a different port:
+
+    python mdns-demo -p <ANOTHER_PORT>
+
+    Waiting for mDNS peer discovery events...
+
+    2025-06-20 23:28:12,052 - libp2p.example.discovery.mdns - INFO - Starting peer Discovery
+
+To discover peers, open another terminal and run the same command with a different port:
+
+.. code-block:: console
+
+    $ python mdns-demo -p 9001
+
+You should see output indicating that a new peer has been discovered:
+
+.. code-block:: console
+
+    Run this from the same folder in another console to start another peer on a different port:
+
+    python mdns-demo -p <ANOTHER_PORT>
+
+    Waiting for mDNS peer discovery events...
+
+    2025-06-20 23:43:43,786 - libp2p.example.discovery.mdns - INFO - Starting peer Discovery
+    2025-06-20 23:43:43,790 - libp2p.example.discovery.mdns - INFO - Discovered: 16Uiu2HAmGxy5NdQEjZWtrYUMrzdp3Syvg7MB2E5Lx8weA9DanYxj
+
+When a new peer is discovered, its peer ID will be printed in the console output.
+
+How it Works
+------------
+
+- Each node advertises itself on the local network using mDNS.
+- When a new peer is discovered, the handler prints its peer ID.
+- This is useful for local peer discovery without requiring a DHT or bootstrap nodes.
+
+You can modify the script to perform additional actions when peers are discovered, such as opening streams or exchanging messages.

docs/examples.rst

@@ -13,3 +13,4 @@ Examples
    examples.pubsub
    examples.circuit_relay
    examples.kademlia
+   examples.mDNS

docs/libp2p.discovery.events.rst

@@ -0,0 +1,21 @@
+libp2p.discovery.events package
+===============================
+
+Submodules
+----------
+
+libp2p.discovery.events.peerDiscovery module
+--------------------------------------------
+
+.. automodule:: libp2p.discovery.events.peerDiscovery
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Module contents
+---------------
+
+.. automodule:: libp2p.discovery.events
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/libp2p.discovery.mdns.rst

@@ -0,0 +1,45 @@
+libp2p.discovery.mdns package
+=============================
+
+Submodules
+----------
+
+libp2p.discovery.mdns.broadcaster module
+----------------------------------------
+
+.. automodule:: libp2p.discovery.mdns.broadcaster
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+libp2p.discovery.mdns.listener module
+-------------------------------------
+
+.. automodule:: libp2p.discovery.mdns.listener
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+libp2p.discovery.mdns.mdns module
+---------------------------------
+
+.. automodule:: libp2p.discovery.mdns.mdns
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+libp2p.discovery.mdns.utils module
+----------------------------------
+
+.. automodule:: libp2p.discovery.mdns.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Module contents
+---------------
+
+.. automodule:: libp2p.discovery.mdns
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/libp2p.discovery.rst

@@ -0,0 +1,22 @@
+libp2p.discovery package
+========================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   libp2p.discovery.events
+   libp2p.discovery.mdns
+
+Submodules
+----------
+
+Module contents
+---------------
+
+.. automodule:: libp2p.discovery
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/libp2p.rst

@@ -8,6 +8,7 @@ Subpackages
    :maxdepth: 4
 
    libp2p.crypto
+   libp2p.discovery
    libp2p.host
    libp2p.identity
    libp2p.io

examples/mDNS/mDNS.py

@@ -0,0 +1,74 @@
+import argparse
+import logging
+import secrets
+
+import multiaddr
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.abc import PeerInfo
+from libp2p.crypto.secp256k1 import (
+    create_new_key_pair,
+)
+from libp2p.discovery.events.peerDiscovery import peerDiscovery
+
+logger = logging.getLogger("libp2p.discovery.mdns")
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setFormatter(
+    logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+)
+logger.addHandler(handler)
+
+# Set root logger to DEBUG to capture all logs from dependencies
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+def onPeerDiscovery(peerinfo: PeerInfo):
+    logger.info(f"Discovered: {peerinfo.peer_id}")
+
+
+async def run(port: int) -> None:
+    secret = secrets.token_bytes(32)
+    key_pair = create_new_key_pair(secret)
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+
+    peerDiscovery.register_peer_discovered_handler(onPeerDiscovery)
+
+    print(
+        "Run this from the same folder in another console to "
+        "start another peer on a different port:\n\n"
+        "mdns-demo -p <ANOTHER_PORT>\n"
+    )
+    print("Waiting for mDNS peer discovery events...\n")
+
+    logger.info("Starting peer Discovery")
+    host = new_host(key_pair=key_pair, enable_mDNS=True)
+    async with host.run(listen_addrs=[listen_addr]):
+        await trio.sleep_forever()
+
+
+def main() -> None:
+    description = """
+    This program demonstrates mDNS peer discovery using libp2p.
+    To use it, run 'mdns-demo -p <PORT>', where <PORT> is the port number.
+    Start multiple peers on different ports to see discovery in action.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("-p", "--port", default=0, type=int, help="source port number")
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose output"
+    )
+    args = parser.parse_args()
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+    try:
+        trio.run(run, args.port)
+    except KeyboardInterrupt:
+        logger.info("Exiting...")
+
+
+if __name__ == "__main__":
+    main()

libp2p/__init__.py

@@ -32,6 +32,9 @@ from libp2p.custom_types import (
     TProtocol,
     TSecurityOptions,
 )
+from libp2p.discovery.mdns.mdns import (
+    MDNSDiscovery,
+)
 from libp2p.host.basic_host import (
     BasicHost,
 )
@@ -81,6 +84,8 @@ DEFAULT_MUXER = "YAMUX"
 # Multiplexer options
 MUXER_YAMUX = "YAMUX"
 MUXER_MPLEX = "MPLEX"
+DEFAULT_NEGOTIATE_TIMEOUT = 5
+
 
 
 def set_default_muxer(muxer_name: Literal["YAMUX", "MPLEX"]) -> None:
@@ -245,6 +250,8 @@ def new_host(
     disc_opt: IPeerRouting | None = None,
     muxer_preference: Literal["YAMUX", "MPLEX"] | None = None,
     listen_addrs: Sequence[multiaddr.Multiaddr] | None = None,
+    enable_mDNS: bool = False,
+    negotiate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
 ) -> IHost:
     """
     Create a new libp2p host based on the given parameters.
@@ -256,6 +263,7 @@ def new_host(
     :param disc_opt: optional discovery
     :param muxer_preference: optional explicit muxer preference
     :param listen_addrs: optional list of multiaddrs to listen on
+    :param enable_mDNS: whether to enable mDNS discovery
     :return: return a host instance
     """
     swarm = new_swarm(
@@ -268,8 +276,7 @@ def new_host(
     )
 
     if disc_opt is not None:
-        return RoutedHost(swarm, disc_opt)
-    return BasicHost(swarm)
-
+        return RoutedHost(swarm, disc_opt, enable_mDNS)
+    return BasicHost(network=swarm,enable_mDNS=enable_mDNS , negotitate_timeout=negotiate_timeout)
 
 __version__ = __version("libp2p")

libp2p/discovery/events/peerDiscovery.py

@@ -0,0 +1,26 @@
+from collections.abc import (
+    Callable,
+)
+
+from libp2p.abc import (
+    PeerInfo,
+)
+
+TTL: int = 60 * 60  # Time-to-live for discovered peers in seconds
+
+
+class PeerDiscovery:
+    def __init__(self) -> None:
+        self._peer_discovered_handlers: list[Callable[[PeerInfo], None]] = []
+
+    def register_peer_discovered_handler(
+        self, handler: Callable[[PeerInfo], None]
+    ) -> None:
+        self._peer_discovered_handlers.append(handler)
+
+    def emit_peer_discovered(self, peer_info: PeerInfo) -> None:
+        for handler in self._peer_discovered_handlers:
+            handler(peer_info)
+
+
+peerDiscovery = PeerDiscovery()

libp2p/discovery/mdns/broadcaster.py

@@ -0,0 +1,91 @@
+import logging
+import socket
+
+from zeroconf import (
+    EventLoopBlocked,
+    ServiceInfo,
+    Zeroconf,
+)
+
+logger = logging.getLogger("libp2p.discovery.mdns.broadcaster")
+
+
+class PeerBroadcaster:
+    """
+    Broadcasts this peer's presence on the local network using mDNS/zeroconf.
+    Registers a service with the peer's ID in the TXT record as per libp2p spec.
+    """
+
+    def __init__(
+        self,
+        zeroconf: Zeroconf,
+        service_type: str,
+        service_name: str,
+        peer_id: str,
+        port: int,
+    ):
+        self.zeroconf = zeroconf
+        self.service_type = service_type
+        self.peer_id = peer_id
+        self.port = port
+        self.service_name = service_name
+
+        # Get the local IP address
+        local_ip = self._get_local_ip()
+        hostname = socket.gethostname()
+
+        self.service_info = ServiceInfo(
+            type_=self.service_type,
+            name=self.service_name,
+            port=self.port,
+            properties={b"id": self.peer_id.encode()},
+            server=f"{hostname}.local.",
+            addresses=[socket.inet_aton(local_ip)],
+        )
+
+    def _get_local_ip(self) -> str:
+        """Get the local IP address of this machine"""
+        try:
+            # Connect to a remote address to determine the local IP
+            # This doesn't actually send data
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+                s.connect(("8.8.8.8", 80))
+                local_ip = s.getsockname()[0]
+            return local_ip
+        except Exception:
+            # Fallback to localhost if we can't determine the IP
+            return "127.0.0.1"
+
+    def register(self) -> None:
+        """Register the peer's mDNS service on the network."""
+        try:
+            self.zeroconf.register_service(self.service_info)
+            logger.debug(f"mDNS service registered: {self.service_name}")
+        except EventLoopBlocked as e:
+            logger.warning(
+                "EventLoopBlocked while registering mDNS '%s': %s", self.service_name, e
+            )
+        except Exception as e:
+            logger.error(
+                "Unexpected error during mDNS registration for '%s': %r",
+                self.service_name,
+                e,
+            )
+
+    def unregister(self) -> None:
+        """Unregister the peer's mDNS service from the network."""
+        try:
+            self.zeroconf.unregister_service(self.service_info)
+            logger.debug(f"mDNS service unregistered: {self.service_name}")
+        except EventLoopBlocked as e:
+            logger.warning(
+                "EventLoopBlocked while unregistering mDNS '%s': %s",
+                self.service_name,
+                e,
+            )
+        except Exception as e:
+            logger.error(
+                "Unexpected error during mDNS unregistration for '%s': %r",
+                self.service_name,
+                e,
+            )

libp2p/discovery/mdns/listener.py

@@ -0,0 +1,83 @@
+import logging
+import socket
+
+from zeroconf import (
+    ServiceBrowser,
+    ServiceInfo,
+    ServiceListener,
+    Zeroconf,
+)
+
+from libp2p.abc import IPeerStore, Multiaddr
+from libp2p.discovery.events.peerDiscovery import peerDiscovery
+from libp2p.peer.id import ID
+from libp2p.peer.peerinfo import PeerInfo
+
+logger = logging.getLogger("libp2p.discovery.mdns.listener")
+
+
+class PeerListener(ServiceListener):
+    """mDNS listener — now a true ServiceListener subclass."""
+
+    def __init__(
+        self,
+        peerstore: IPeerStore,
+        zeroconf: Zeroconf,
+        service_type: str,
+        service_name: str,
+    ) -> None:
+        self.peerstore = peerstore
+        self.zeroconf = zeroconf
+        self.service_type = service_type
+        self.service_name = service_name
+        self.discovered_services: dict[str, ID] = {}
+        self.browser = ServiceBrowser(self.zeroconf, self.service_type, listener=self)
+
+    def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        if name == self.service_name:
+            return
+        logger.debug(f"Adding service: {name}")
+        info = zc.get_service_info(type_, name, timeout=5000)
+        if not info:
+            return
+        peer_info = self._extract_peer_info(info)
+        if peer_info:
+            self.discovered_services[name] = peer_info.peer_id
+            self.peerstore.add_addrs(peer_info.peer_id, peer_info.addrs, 10)
+            peerDiscovery.emit_peer_discovered(peer_info)
+            logger.debug(f"Discovered Peer: {peer_info.peer_id}")
+
+    def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        if name == self.service_name:
+            return
+        logger.debug(f"Removing service: {name}")
+        peer_id = self.discovered_services.pop(name)
+        self.peerstore.clear_addrs(peer_id)
+        logger.debug(f"Removed Peer: {peer_id}")
+
+    def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        info = zc.get_service_info(type_, name, timeout=5000)
+        if not info:
+            return
+        peer_info = self._extract_peer_info(info)
+        if peer_info:
+            self.peerstore.clear_addrs(peer_info.peer_id)
+            self.peerstore.add_addrs(peer_info.peer_id, peer_info.addrs, 10)
+            logger.debug(f"Updated Peer {peer_info.peer_id}")
+
+    def _extract_peer_info(self, info: ServiceInfo) -> PeerInfo | None:
+        try:
+            addrs = [
+                Multiaddr(f"/ip4/{socket.inet_ntoa(addr)}/tcp/{info.port}")
+                for addr in info.addresses
+            ]
+            pid_bytes = info.properties.get(b"id")
+            if not pid_bytes:
+                return None
+            pid = ID.from_base58(pid_bytes.decode())
+            return PeerInfo(peer_id=pid, addrs=addrs)
+        except Exception:
+            return None
+
+    def stop(self) -> None:
+        self.browser.cancel()

libp2p/discovery/mdns/mdns.py

@@ -0,0 +1,73 @@
+"""
+mDNS-based peer discovery for py-libp2p.
+Conforms to https://github.com/libp2p/specs/blob/master/discovery/mdns.md
+Uses zeroconf for mDNS broadcast/listen. Async operations use trio.
+"""
+
+import logging
+
+from zeroconf import (
+    Zeroconf,
+)
+
+from libp2p.abc import (
+    INetworkService,
+)
+
+from .broadcaster import (
+    PeerBroadcaster,
+)
+from .listener import (
+    PeerListener,
+)
+from .utils import (
+    stringGen,
+)
+
+logger = logging.getLogger("libp2p.discovery.mdns")
+
+SERVICE_TYPE = "_p2p._udp.local."
+MCAST_PORT = 5353
+MCAST_ADDR = "224.0.0.251"
+
+
+class MDNSDiscovery:
+    """
+    mDNS-based peer discovery for py-libp2p, using zeroconf.
+    Conforms to the libp2p mDNS discovery spec.
+    """
+
+    def __init__(self, swarm: INetworkService, port: int = 8000):
+        self.peer_id = str(swarm.get_peer_id())
+        self.port = port
+        self.zeroconf = Zeroconf()
+        self.serviceName = f"{stringGen()}.{SERVICE_TYPE}"
+        self.peerstore = swarm.peerstore
+        self.swarm = swarm
+        self.broadcaster = PeerBroadcaster(
+            zeroconf=self.zeroconf,
+            service_type=SERVICE_TYPE,
+            service_name=self.serviceName,
+            peer_id=self.peer_id,
+            port=self.port,
+        )
+        self.listener = PeerListener(
+            zeroconf=self.zeroconf,
+            peerstore=self.peerstore,
+            service_type=SERVICE_TYPE,
+            service_name=self.serviceName,
+        )
+
+    def start(self) -> None:
+        """Register this peer and start listening for others."""
+        logger.debug(
+            f"Starting mDNS discovery for peer {self.peer_id} on port {self.port}"
+        )
+        self.broadcaster.register()
+        # Listener is started in constructor
+
+    def stop(self) -> None:
+        """Unregister this peer and clean up zeroconf resources."""
+        logger.debug("Stopping mDNS discovery")
+        self.broadcaster.unregister()
+        self.zeroconf.close()

libp2p/discovery/mdns/utils.py

@@ -0,0 +1,11 @@
+import random
+import string
+
+
+def stringGen(len: int = 63) -> str:
+    """Generate a random string of lowercase letters and digits."""
+    charset = string.ascii_lowercase + string.digits
+    result = []
+    for _ in range(len):
+        result.append(random.choice(charset))
+    return "".join(result)

libp2p/host/basic_host.py

@@ -29,6 +29,7 @@ from libp2p.custom_types import (
     StreamHandlerFn,
     TProtocol,
 )
+from libp2p.discovery.mdns.mdns import MDNSDiscovery
 from libp2p.host.defaults import (
     get_default_protocols,
 )
@@ -70,6 +71,7 @@ if TYPE_CHECKING:
 
 
 logger = logging.getLogger("libp2p.network.basic_host")
+DEFAULT_NEGOTIATE_TIMEOUT = 5
 
 
 class BasicHost(IHost):
@@ -89,15 +91,20 @@ class BasicHost(IHost):
     def __init__(
         self,
         network: INetworkService,
+        enable_mDNS: bool = False,
         default_protocols: Optional["OrderedDict[TProtocol, StreamHandlerFn]"] = None,
+        negotitate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
     ) -> None:
         self._network = network
         self._network.set_stream_handler(self._swarm_stream_handler)
         self.peerstore = self._network.peerstore
+        self.negotiate_timeout = negotitate_timeout
         # Protocol muxing
         default_protocols = default_protocols or get_default_protocols(self)
         self.multiselect = Multiselect(dict(default_protocols.items()))
         self.multiselect_client = MultiselectClient()
+        if enable_mDNS:
+            self.mDNS = MDNSDiscovery(network)
 
     def get_id(self) -> ID:
         """
@@ -162,7 +169,14 @@ class BasicHost(IHost):
             network = self.get_network()
             async with background_trio_service(network):
                 await network.listen(*listen_addrs)
-                yield
+                if hasattr(self, "mDNS") and self.mDNS is not None:
+                    logger.debug("Starting mDNS Discovery")
+                    self.mDNS.start()
+                try:
+                    yield
+                finally:
+                    if hasattr(self, "mDNS") and self.mDNS is not None:
+                        self.mDNS.stop()
 
         return _run()
 
@@ -178,7 +192,10 @@ class BasicHost(IHost):
         self.multiselect.add_handler(protocol_id, stream_handler)
 
     async def new_stream(
-        self, peer_id: ID, protocol_ids: Sequence[TProtocol]
+        self,
+        peer_id: ID,
+        protocol_ids: Sequence[TProtocol],
+        negotitate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
     ) -> INetStream:
         """
         :param peer_id: peer_id that host is connecting
@@ -190,7 +207,9 @@ class BasicHost(IHost):
         # Perform protocol muxing to determine protocol to use
         try:
             selected_protocol = await self.multiselect_client.select_one_of(
-                list(protocol_ids), MultiselectCommunicator(net_stream)
+                list(protocol_ids),
+                MultiselectCommunicator(net_stream),
+                negotitate_timeout,
             )
         except MultiselectClientError as error:
             logger.debug("fail to open a stream to peer %s, error=%s", peer_id, error)
@@ -200,7 +219,12 @@ class BasicHost(IHost):
         net_stream.set_protocol(selected_protocol)
         return net_stream
 
-    async def send_command(self, peer_id: ID, command: str) -> list[str]:
+    async def send_command(
+        self,
+        peer_id: ID,
+        command: str,
+        response_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
+    ) -> list[str]:
         """
         Send a multistream-select command to the specified peer and return
         the response.
@@ -214,7 +238,7 @@ class BasicHost(IHost):
 
         try:
             response = await self.multiselect_client.query_multistream_command(
-                MultiselectCommunicator(new_stream), command
+                MultiselectCommunicator(new_stream), command, response_timeout
             )
         except MultiselectClientError as error:
             logger.debug("fail to open a stream to peer %s, error=%s", peer_id, error)
@@ -253,7 +277,7 @@ class BasicHost(IHost):
         # Perform protocol muxing to determine protocol to use
         try:
             protocol, handler = await self.multiselect.negotiate(
-                MultiselectCommunicator(net_stream)
+                MultiselectCommunicator(net_stream), self.negotiate_timeout
             )
         except MultiselectError as error:
             peer_id = net_stream.muxed_conn.peer_id

libp2p/host/routed_host.py

@@ -18,8 +18,10 @@ from libp2p.peer.peerinfo import (
 class RoutedHost(BasicHost):
     _router: IPeerRouting
 
-    def __init__(self, network: INetworkService, router: IPeerRouting):
-        super().__init__(network)
+    def __init__(
+        self, network: INetworkService, router: IPeerRouting, enable_mDNS: bool = False
+    ):
+        super().__init__(network, enable_mDNS)
         self._router = router
 
     async def connect(self, peer_info: PeerInfo) -> None:

libp2p/identity/identify_push/identify_push.py

@@ -40,6 +40,7 @@ logger = logging.getLogger(__name__)
 ID_PUSH = TProtocol("/ipfs/id/push/1.0.0")
 PROTOCOL_VERSION = "ipfs/0.1.0"
 AGENT_VERSION = get_agent_version()
+CONCURRENCY_LIMIT = 10
 
 
 def identify_push_handler_for(host: IHost) -> StreamHandlerFn:
@@ -132,7 +133,10 @@ async def _update_peerstore_from_identify(
 
 
 async def push_identify_to_peer(
-    host: IHost, peer_id: ID, observed_multiaddr: Multiaddr | None = None
+    host: IHost,
+    peer_id: ID,
+    observed_multiaddr: Multiaddr | None = None,
+    limit: trio.Semaphore = trio.Semaphore(CONCURRENCY_LIMIT),
 ) -> bool:
     """
     Push an identify message to a specific peer.
@@ -146,25 +150,26 @@ async def push_identify_to_peer(
         True if the push was successful, False otherwise.
 
     """
-    try:
-        # Create a new stream to the peer using the identify/push protocol
-        stream = await host.new_stream(peer_id, [ID_PUSH])
+    async with limit:
+        try:
+            # Create a new stream to the peer using the identify/push protocol
+            stream = await host.new_stream(peer_id, [ID_PUSH])
 
-        # Create the identify message
-        identify_msg = _mk_identify_protobuf(host, observed_multiaddr)
-        response = identify_msg.SerializeToString()
+            # Create the identify message
+            identify_msg = _mk_identify_protobuf(host, observed_multiaddr)
+            response = identify_msg.SerializeToString()
 
-        # Send the identify message
-        await stream.write(response)
+            # Send the identify message
+            await stream.write(response)
 
-        # Close the stream
-        await stream.close()
+            # Close the stream
+            await stream.close()
 
-        logger.debug("Successfully pushed identify to peer %s", peer_id)
-        return True
-    except Exception as e:
-        logger.error("Error pushing identify to peer %s: %s", peer_id, e)
-        return False
+            logger.debug("Successfully pushed identify to peer %s", peer_id)
+            return True
+        except Exception as e:
+            logger.error("Error pushing identify to peer %s: %s", peer_id, e)
+            return False
 
 
 async def push_identify_to_peers(
@@ -179,13 +184,10 @@ async def push_identify_to_peers(
     """
     if peer_ids is None:
         # Get all connected peers
-        peer_ids = set(host.get_peerstore().peer_ids())
+        peer_ids = set(host.get_connected_peers())
 
     # Push to each peer in parallel using a trio.Nursery
-    # TODO: Consider using a bounded nursery to limit concurrency
-    # and avoid overwhelming the network. This can be done by using
-    # trio.open_nursery(max_concurrent=10) or similar.
-    # For now, we will use an unbounded nursery for simplicity.
+    # limiting concurrent connections to 10
     async with trio.open_nursery() as nursery:
         for peer_id in peer_ids:
             nursery.start_soon(push_identify_to_peer, host, peer_id, observed_multiaddr)

libp2p/protocol_muxer/multiselect.py

@@ -1,3 +1,5 @@
+import trio
+
 from libp2p.abc import (
     IMultiselectCommunicator,
     IMultiselectMuxer,
@@ -14,6 +16,7 @@ from .exceptions import (
 
 MULTISELECT_PROTOCOL_ID = "/multistream/1.0.0"
 PROTOCOL_NOT_FOUND_MSG = "na"
+DEFAULT_NEGOTIATE_TIMEOUT = 5
 
 
 class Multiselect(IMultiselectMuxer):
@@ -47,47 +50,56 @@ class Multiselect(IMultiselectMuxer):
 
     # FIXME: Make TProtocol Optional[TProtocol] to keep types consistent
     async def negotiate(
-        self, communicator: IMultiselectCommunicator
+        self,
+        communicator: IMultiselectCommunicator,
+        negotiate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
     ) -> tuple[TProtocol, StreamHandlerFn | None]:
         """
         Negotiate performs protocol selection.
 
         :param stream: stream to negotiate on
+        :param negotiate_timeout: timeout for negotiation
         :return: selected protocol name, handler function
         :raise MultiselectError: raised when negotiation failed
         """
-        await self.handshake(communicator)
+        try:
+            with trio.fail_after(negotiate_timeout):
+                await self.handshake(communicator)
 
-        while True:
-            try:
-                command = await communicator.read()
-            except MultiselectCommunicatorError as error:
-                raise MultiselectError() from error
-
-            if command == "ls":
-                supported_protocols = [p for p in self.handlers.keys() if p is not None]
-                response = "\n".join(supported_protocols) + "\n"
-
-                try:
-                    await communicator.write(response)
-                except MultiselectCommunicatorError as error:
-                    raise MultiselectError() from error
-
-            else:
-                protocol = TProtocol(command)
-                if protocol in self.handlers:
+                while True:
                     try:
-                        await communicator.write(protocol)
+                        command = await communicator.read()
                     except MultiselectCommunicatorError as error:
                         raise MultiselectError() from error
 
-                    return protocol, self.handlers[protocol]
-                try:
-                    await communicator.write(PROTOCOL_NOT_FOUND_MSG)
-                except MultiselectCommunicatorError as error:
-                    raise MultiselectError() from error
+                    if command == "ls":
+                        supported_protocols = [
+                            p for p in self.handlers.keys() if p is not None
+                        ]
+                        response = "\n".join(supported_protocols) + "\n"
 
-        raise MultiselectError("Negotiation failed: no matching protocol")
+                        try:
+                            await communicator.write(response)
+                        except MultiselectCommunicatorError as error:
+                            raise MultiselectError() from error
+
+                    else:
+                        protocol = TProtocol(command)
+                        if protocol in self.handlers:
+                            try:
+                                await communicator.write(protocol)
+                            except MultiselectCommunicatorError as error:
+                                raise MultiselectError() from error
+
+                            return protocol, self.handlers[protocol]
+                        try:
+                            await communicator.write(PROTOCOL_NOT_FOUND_MSG)
+                        except MultiselectCommunicatorError as error:
+                            raise MultiselectError() from error
+
+                raise MultiselectError("Negotiation failed: no matching protocol")
+        except trio.TooSlowError:
+            raise MultiselectError("handshake read timeout")
 
     async def handshake(self, communicator: IMultiselectCommunicator) -> None:
         """

libp2p/protocol_muxer/multiselect_client.py

@@ -2,6 +2,8 @@ from collections.abc import (
     Sequence,
 )
 
+import trio
+
 from libp2p.abc import (
     IMultiselectClient,
     IMultiselectCommunicator,
@@ -17,6 +19,7 @@ from .exceptions import (
 
 MULTISELECT_PROTOCOL_ID = "/multistream/1.0.0"
 PROTOCOL_NOT_FOUND_MSG = "na"
+DEFAULT_NEGOTIATE_TIMEOUT = 5
 
 
 class MultiselectClient(IMultiselectClient):
@@ -40,6 +43,7 @@ class MultiselectClient(IMultiselectClient):
 
         try:
             handshake_contents = await communicator.read()
+
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error
 
@@ -47,7 +51,10 @@ class MultiselectClient(IMultiselectClient):
             raise MultiselectClientError("multiselect protocol ID mismatch")
 
     async def select_one_of(
-        self, protocols: Sequence[TProtocol], communicator: IMultiselectCommunicator
+        self,
+        protocols: Sequence[TProtocol],
+        communicator: IMultiselectCommunicator,
+        negotitate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
     ) -> TProtocol:
         """
         For each protocol, send message to multiselect selecting protocol and
@@ -56,22 +63,32 @@ class MultiselectClient(IMultiselectClient):
 
         :param protocol: protocol to select
         :param communicator: communicator to use to communicate with counterparty
+        :param negotiate_timeout: timeout for negotiation
         :return: selected protocol
         :raise MultiselectClientError: raised when protocol negotiation failed
         """
-        await self.handshake(communicator)
+        try:
+            with trio.fail_after(negotitate_timeout):
+                await self.handshake(communicator)
 
-        for protocol in protocols:
-            try:
-                selected_protocol = await self.try_select(communicator, protocol)
-                return selected_protocol
-            except MultiselectClientError:
-                pass
+                for protocol in protocols:
+                    try:
+                        selected_protocol = await self.try_select(
+                            communicator, protocol
+                        )
+                        return selected_protocol
+                    except MultiselectClientError:
+                        pass
 
-        raise MultiselectClientError("protocols not supported")
+                raise MultiselectClientError("protocols not supported")
+        except trio.TooSlowError:
+            raise MultiselectClientError("response timed out")
 
     async def query_multistream_command(
-        self, communicator: IMultiselectCommunicator, command: str
+        self,
+        communicator: IMultiselectCommunicator,
+        command: str,
+        response_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
     ) -> list[str]:
         """
         Send a multistream-select command over the given communicator and return
@@ -79,26 +96,32 @@ class MultiselectClient(IMultiselectClient):
 
         :param communicator: communicator to use to communicate with counterparty
         :param command: supported multistream-select command(e.g., ls)
+        :param negotiate_timeout: timeout for negotiation
         :raise MultiselectClientError: If the communicator fails to process data.
         :return: list of strings representing the response from peer.
         """
-        await self.handshake(communicator)
-
-        if command == "ls":
-            try:
-                await communicator.write("ls")
-            except MultiselectCommunicatorError as error:
-                raise MultiselectClientError() from error
-        else:
-            raise ValueError("Command not supported")
-
         try:
-            response = await communicator.read()
-            response_list = response.strip().splitlines()
-        except MultiselectCommunicatorError as error:
-            raise MultiselectClientError() from error
+            with trio.fail_after(response_timeout):
+                await self.handshake(communicator)
 
-        return response_list
+                if command == "ls":
+                    try:
+                        await communicator.write("ls")
+                    except MultiselectCommunicatorError as error:
+                        raise MultiselectClientError() from error
+                else:
+                    raise ValueError("Command not supported")
+
+                try:
+                    response = await communicator.read()
+                    response_list = response.strip().splitlines()
+
+                except MultiselectCommunicatorError as error:
+                    raise MultiselectClientError() from error
+
+                return response_list
+        except trio.TooSlowError:
+            raise MultiselectClientError("command response timed out")
 
     async def try_select(
         self, communicator: IMultiselectCommunicator, protocol: TProtocol
@@ -118,6 +141,7 @@ class MultiselectClient(IMultiselectClient):
 
         try:
             response = await communicator.read()
+
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error
 

libp2p/pubsub/floodsub.py

@@ -12,15 +12,9 @@ from libp2p.abc import (
 from libp2p.custom_types import (
     TProtocol,
 )
-from libp2p.network.stream.exceptions import (
-    StreamClosed,
-)
 from libp2p.peer.id import (
     ID,
 )
-from libp2p.utils import (
-    encode_varint_prefixed,
-)
 
 from .exceptions import (
     PubsubRouterError,
@@ -120,13 +114,7 @@ class FloodSub(IPubsubRouter):
             if peer_id not in pubsub.peers:
                 continue
             stream = pubsub.peers[peer_id]
-            # FIXME: We should add a `WriteMsg` similar to write delimited messages.
-            #   Ref: https://github.com/libp2p/go-libp2p-pubsub/blob/master/comm.go#L107
-            try:
-                await stream.write(encode_varint_prefixed(rpc_msg.SerializeToString()))
-            except StreamClosed:
-                logger.debug("Fail to publish message to %s: stream closed", peer_id)
-                pubsub._handle_dead_peer(peer_id)
+            await pubsub.write_msg(stream, rpc_msg)
 
     async def join(self, topic: str) -> None:
         """

libp2p/pubsub/gossipsub.py

@@ -24,9 +24,6 @@ from libp2p.abc import (
 from libp2p.custom_types import (
     TProtocol,
 )
-from libp2p.network.stream.exceptions import (
-    StreamClosed,
-)
 from libp2p.peer.id import (
     ID,
 )
@@ -44,9 +41,6 @@ from libp2p.pubsub import (
 from libp2p.tools.async_service import (
     Service,
 )
-from libp2p.utils import (
-    encode_varint_prefixed,
-)
 
 from .exceptions import (
     NoPubsubAttached,
@@ -267,13 +261,10 @@ class GossipSub(IPubsubRouter, Service):
             if peer_id not in self.pubsub.peers:
                 continue
             stream = self.pubsub.peers[peer_id]
-            # FIXME: We should add a `WriteMsg` similar to write delimited messages.
-            #   Ref: https://github.com/libp2p/go-libp2p-pubsub/blob/master/comm.go#L107
-            try:
-                await stream.write(encode_varint_prefixed(rpc_msg.SerializeToString()))
-            except StreamClosed:
-                logger.debug("Fail to publish message to %s: stream closed", peer_id)
-                self.pubsub._handle_dead_peer(peer_id)
+
+            # TODO: Go use `sendRPC`, which possibly piggybacks gossip/control messages.
+            await self.pubsub.write_msg(stream, rpc_msg)
+
         for topic in pubsub_msg.topicIDs:
             self.time_since_last_publish[topic] = int(time.time())
 
@@ -829,8 +820,6 @@ class GossipSub(IPubsubRouter, Service):
 
         packet.publish.extend(msgs_to_forward)
 
-        # 2) Serialize that packet
-        rpc_msg: bytes = packet.SerializeToString()
         if self.pubsub is None:
             raise NoPubsubAttached
 
@@ -844,14 +833,7 @@ class GossipSub(IPubsubRouter, Service):
         peer_stream = self.pubsub.peers[sender_peer_id]
 
         # 4) And write the packet to the stream
-        try:
-            await peer_stream.write(encode_varint_prefixed(rpc_msg))
-        except StreamClosed:
-            logger.debug(
-                "Fail to responed to iwant request from %s: stream closed",
-                sender_peer_id,
-            )
-            self.pubsub._handle_dead_peer(sender_peer_id)
+        await self.pubsub.write_msg(peer_stream, packet)
 
     async def handle_graft(
         self, graft_msg: rpc_pb2.ControlGraft, sender_peer_id: ID
@@ -993,8 +975,6 @@ class GossipSub(IPubsubRouter, Service):
         packet: rpc_pb2.RPC = rpc_pb2.RPC()
         packet.control.CopyFrom(control_msg)
 
-        rpc_msg: bytes = packet.SerializeToString()
-
         # Get stream for peer from pubsub
         if to_peer not in self.pubsub.peers:
             logger.debug(
@@ -1004,8 +984,4 @@ class GossipSub(IPubsubRouter, Service):
         peer_stream = self.pubsub.peers[to_peer]
 
         # Write rpc to stream
-        try:
-            await peer_stream.write(encode_varint_prefixed(rpc_msg))
-        except StreamClosed:
-            logger.debug("Fail to emit control message to %s: stream closed", to_peer)
-            self.pubsub._handle_dead_peer(to_peer)
+        await self.pubsub.write_msg(peer_stream, packet)

libp2p/pubsub/pubsub.py

@@ -66,6 +66,7 @@ from libp2p.utils import (
     encode_varint_prefixed,
     read_varint_prefixed_bytes,
 )
+from libp2p.utils.varint import encode_uvarint
 
 from .pb import (
     rpc_pb2,
@@ -778,3 +779,43 @@ class Pubsub(Service, IPubsub):
 
     def _is_subscribed_to_msg(self, msg: rpc_pb2.Message) -> bool:
         return any(topic in self.topic_ids for topic in msg.topicIDs)
+
+    async def write_msg(self, stream: INetStream, rpc_msg: rpc_pb2.RPC) -> bool:
+        """
+        Write an RPC message to a stream with proper error handling.
+
+        Implements WriteMsg similar to go-msgio which is used in go-libp2p
+        Ref: https://github.com/libp2p/go-msgio/blob/master/protoio/uvarint_writer.go#L56
+
+
+        :param stream: stream to write the message to
+        :param rpc_msg: RPC message to write
+        :return: True if successful, False if stream was closed
+        """
+        try:
+            # Calculate message size first
+            msg_bytes = rpc_msg.SerializeToString()
+            msg_size = len(msg_bytes)
+
+            # Calculate varint size and allocate exact buffer size needed
+
+            varint_bytes = encode_uvarint(msg_size)
+            varint_size = len(varint_bytes)
+
+            # Allocate buffer with exact size (like Go's pool.Get())
+            buf = bytearray(varint_size + msg_size)
+
+            # Write varint length prefix to buffer (like Go's binary.PutUvarint())
+            buf[:varint_size] = varint_bytes
+
+            # Write serialized message after varint (like Go's rpc.MarshalTo())
+            buf[varint_size:] = msg_bytes
+
+            # Single write operation (like Go's s.Write(buf))
+            await stream.write(bytes(buf))
+            return True
+        except StreamClosed:
+            peer_id = stream.muxed_conn.peer_id
+            logger.debug("Fail to write message to %s: stream closed", peer_id)
+            self._handle_dead_peer(peer_id)
+            return False

libp2p/stream_muxer/muxer_multistream.py

@@ -31,9 +31,6 @@ from libp2p.stream_muxer.yamux.yamux import (
     Yamux,
 )
 
-# FIXME: add negotiate timeout to `MuxerMultistream`
-DEFAULT_NEGOTIATE_TIMEOUT = 60
-
 
 class MuxerMultistream:
     """

libp2p/stream_muxer/yamux/yamux.py

@@ -493,7 +493,7 @@ class Yamux(IMuxedConn):
                     f"type={typ}, flags={flags}, stream_id={stream_id},"
                     f"length={length}"
                 )
-                if typ == TYPE_DATA and flags & FLAG_SYN:
+                if (typ == TYPE_DATA or typ == TYPE_WINDOW_UPDATE) and flags & FLAG_SYN:
                     async with self.streams_lock:
                         if stream_id not in self.streams:
                             stream = YamuxStream(stream_id, self, False)

newsfragments/621.feature.rst

@@ -0,0 +1 @@
+Limit concurrency in `push_identify_to_peers` to prevent resource congestion under high peer counts.

newsfragments/649.feature.rst

@@ -0,0 +1 @@
+Added support for ``Multicast DNS`` in py-libp2p

newsfragments/687.feature.rst

@@ -0,0 +1 @@
+Optimized pubsub message writing by implementing a write_msg() method that uses pre-allocated buffers and single write operations, improving performance by eliminating separate varint prefix encoding and write operations in FloodSub and GossipSub.

newsfragments/696.bugfix.rst

@@ -0,0 +1,4 @@
+Add timeout wrappers in:
+1. multiselect.py: `negotiate` function
+2. multiselect_client.py: `select_one_of` , `query_multistream_command` functions
+to prevent indefinite hangs when a remote peer does not respond.

newsfragments/701.bugfix.rst

@@ -0,0 +1 @@
+align stream creation logic with yamux specification

newsfragments/707.feature.rst

@@ -0,0 +1 @@
+Added comprehensive tests for pubsub connection utility functions to verify degree limits are enforced, excess peers are handled correctly, and edge cases (degree=0, negative values, empty lists) are managed gracefully.

pyproject.toml

@@ -1,4 +1,3 @@
-
 [build-system]
 requires = ["setuptools>=42", "wheel"]
 build-backend = "setuptools.build_meta"
@@ -23,7 +22,7 @@ dependencies = [
     "multiaddr>=0.0.9",
     "mypy-protobuf>=3.0.0",
     "noiseprotocol>=0.3.0",
-    "protobuf>=3.20.1,<4.0.0",
+    "protobuf>=4.21.0,<5.0.0",
     "pycryptodome>=3.9.2",
     "pymultihash>=0.8.2",
     "pynacl>=1.3.0",
@@ -31,6 +30,7 @@ dependencies = [
     "trio-typing>=0.0.4",
     "trio>=0.26.0",
     "fastecdsa==2.3.2; sys_platform != 'win32'",
+    "zeroconf (>=0.147.0,<0.148.0)",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -54,6 +54,7 @@ identify-demo = "examples.identify.identify:main"
 identify-push-demo = "examples.identify_push.identify_push_demo:run_main"
 identify-push-listener-dialer-demo = "examples.identify_push.identify_push_listener_dialer:main"
 pubsub-demo = "examples.pubsub.pubsub:main"
+mdns-demo = "examples.mDNS.mDNS:main"
 
 [project.optional-dependencies]
 dev = [

tests/core/identity/identify_push/test_identify_push.py

@@ -1,4 +1,7 @@
 import logging
+from unittest.mock import (
+    patch,
+)
 
 import pytest
 import multiaddr
@@ -17,6 +20,7 @@ from libp2p.identity.identify.pb.identify_pb2 import (
     Identify,
 )
 from libp2p.identity.identify_push.identify_push import (
+    CONCURRENCY_LIMIT,
     ID_PUSH,
     _update_peerstore_from_identify,
     identify_push_handler_for,
@@ -29,6 +33,9 @@ from libp2p.peer.peerinfo import (
 from tests.utils.factories import (
     host_pair_factory,
 )
+from tests.utils.utils import (
+    create_mock_connections,
+)
 
 logger = logging.getLogger("libp2p.identity.identify-push-test")
 
@@ -175,6 +182,7 @@ async def test_identify_push_to_peers(security_protocol):
         host_c = new_host(key_pair=key_pair_c)
 
         # Set up the identify/push handlers
+        host_a.set_stream_handler(ID_PUSH, identify_push_handler_for(host_a))
         host_b.set_stream_handler(ID_PUSH, identify_push_handler_for(host_b))
         host_c.set_stream_handler(ID_PUSH, identify_push_handler_for(host_c))
 
@@ -204,6 +212,20 @@ async def test_identify_push_to_peers(security_protocol):
             # Check that the peer is in the peerstore
             assert peer_id_a in peerstore_c.peer_ids()
 
+            # Test for push_identify to only connected peers and not all peers
+            # Disconnect a from c.
+            await host_c.disconnect(host_a.get_id())
+
+            await push_identify_to_peers(host_c)
+
+            # Wait a bit for the push to complete
+            await trio.sleep(0.1)
+
+            # Check that host_a's peerstore has not been updated with host_c's info
+            assert host_c.get_id() not in host_a.get_peerstore().peer_ids()
+            # Check that host_b's peerstore has been updated with host_c's info
+            assert host_c.get_id() in host_b.get_peerstore().peer_ids()
+
 
 @pytest.mark.trio
 async def test_push_identify_to_peers_with_explicit_params(security_protocol):
@@ -412,3 +434,72 @@ async def test_partial_update_peerstore_from_identify(security_protocol):
         host_a_public_key = host_a.get_public_key().serialize()
         peerstore_public_key = peerstore.pubkey(peer_id).serialize()
         assert host_a_public_key == peerstore_public_key
+
+
+@pytest.mark.trio
+async def test_push_identify_to_peers_respects_concurrency_limit():
+    """
+    Test bounded concurrency for the identify/push protocol to prevent
+    network congestion.
+
+    This test verifies:
+    1. The number of concurrent tasks executing the identify push is always
+       less than or equal to CONCURRENCY_LIMIT.
+    2. An error is raised if concurrency exceeds the defined limit.
+
+    It mocks `push_identify_to_peer` to simulate delay using sleep,
+    allowing the test to measure and assert actual concurrency behavior.
+    """
+    state = {
+        "concurrency_counter": 0,
+        "max_observed": 0,
+    }
+    lock = trio.Lock()
+
+    async def mock_push_identify_to_peer(
+        host, peer_id, observed_multiaddr=None, limit=trio.Semaphore(CONCURRENCY_LIMIT)
+    ) -> bool:
+        """
+        Mock function to test concurrency by simulating an identify message.
+
+        This function patches push_identify_to_peer for testing purpose
+
+        Returns
+        -------
+        bool
+            True if the push was successful, False otherwise.
+
+        """
+        async with limit:
+            async with lock:
+                state["concurrency_counter"] += 1
+                if state["concurrency_counter"] > CONCURRENCY_LIMIT:
+                    raise RuntimeError(
+                        f"Concurrency limit exceeded: {state['concurrency_counter']}"
+                    )
+                state["max_observed"] = max(
+                    state["max_observed"], state["concurrency_counter"]
+                )
+
+            logger.debug("Successfully pushed identify to peer %s", peer_id)
+            await trio.sleep(0.05)
+
+            async with lock:
+                state["concurrency_counter"] -= 1
+
+            return True
+
+    # Create a mock host.
+    key_pair_host = create_new_key_pair()
+    host = new_host(key_pair=key_pair_host)
+
+    # Create a mock network and add mock connections to the host
+    host.get_network().connections = create_mock_connections()
+    with patch(
+        "libp2p.identity.identify_push.identify_push.push_identify_to_peer",
+        new=mock_push_identify_to_peer,
+    ):
+        await push_identify_to_peers(host)
+    assert state["max_observed"] <= CONCURRENCY_LIMIT, (
+        f"Max concurrency observed: {state['max_observed']}"
+    )

tests/core/protocol_muxer/test_negotiate_timeout.py

@@ -0,0 +1,59 @@
+import pytest
+import trio
+
+from libp2p.abc import (
+    IMultiselectCommunicator,
+)
+from libp2p.custom_types import TProtocol
+from libp2p.protocol_muxer.exceptions import (
+    MultiselectClientError,
+    MultiselectError,
+)
+from libp2p.protocol_muxer.multiselect import Multiselect
+from libp2p.protocol_muxer.multiselect_client import MultiselectClient
+
+
+class DummyMultiselectCommunicator(IMultiselectCommunicator):
+    """
+    Dummy MultiSelectCommunicator to test out negotiate timmeout.
+    """
+
+    def __init__(self) -> None:
+        return
+
+    async def write(self, msg_str: str) -> None:
+        """Goes into infinite loop when .write is called"""
+        await trio.sleep_forever()
+
+    async def read(self) -> str:
+        """Returns a dummy read"""
+        return "dummy_read"
+
+
+@pytest.mark.trio
+async def test_select_one_of_timeout():
+    ECHO = TProtocol("/echo/1.0.0")
+    communicator = DummyMultiselectCommunicator()
+
+    client = MultiselectClient()
+
+    with pytest.raises(MultiselectClientError, match="response timed out"):
+        await client.select_one_of([ECHO], communicator, 2)
+
+
+@pytest.mark.trio
+async def test_query_multistream_command_timeout():
+    communicator = DummyMultiselectCommunicator()
+    client = MultiselectClient()
+
+    with pytest.raises(MultiselectClientError, match="response timed out"):
+        await client.query_multistream_command(communicator, "ls", 2)
+
+
+@pytest.mark.trio
+async def test_negotiate_timeout():
+    communicator = DummyMultiselectCommunicator()
+    server = Multiselect()
+
+    with pytest.raises(MultiselectError, match="handshake read timeout"):
+        await server.negotiate(communicator, 2)

tests/core/pubsub/test_gossipsub.py

@@ -15,6 +15,7 @@ from tests.utils.factories import (
     PubsubFactory,
 )
 from tests.utils.pubsub.utils import (
+    connect_some,
     dense_connect,
     one_to_all_connect,
     sparse_connect,
@@ -590,3 +591,166 @@ async def test_sparse_connect():
                 f"received the message. Ideally all nodes should receive it, but at "
                 f"minimum {min_required} required for sparse network scalability."
             )
+
+
+@pytest.mark.trio
+async def test_connect_some_with_fewer_hosts_than_degree():
+    """Test connect_some when there are fewer hosts than degree."""
+    # Create 3 hosts with degree=5
+    async with PubsubFactory.create_batch_with_floodsub(3) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+        degree = 5
+
+        await connect_some(hosts, degree)
+        await trio.sleep(0.1)  # Allow connections to establish
+
+        # Each host should connect to all other hosts (since there are only 2 others)
+        for i, pubsub in enumerate(pubsubs_fsub):
+            connected_peers = len(pubsub.peers)
+            expected_max_connections = len(hosts) - 1  # All others
+            assert connected_peers <= expected_max_connections, (
+                f"Host {i} has {connected_peers} connections, "
+                f"but can only connect to {expected_max_connections} others"
+            )
+
+
+@pytest.mark.trio
+async def test_connect_some_degree_limit_enforced():
+    """Test that connect_some enforces degree limits and creates expected topology."""
+    # Test with small network where we can verify exact behavior
+    async with PubsubFactory.create_batch_with_floodsub(6) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+        degree = 2
+
+        await connect_some(hosts, degree)
+        await trio.sleep(0.1)
+
+        # With 6 hosts and degree=2, expected connections:
+        # Host 0 → connects to hosts 1,2 (2 peers total)
+        # Host 1 → connects to hosts 2,3 (3 peers: 0,2,3)
+        # Host 2 → connects to hosts 3,4 (4 peers: 0,1,3,4)
+        # Host 3 → connects to hosts 4,5 (3 peers: 1,2,4,5) - wait, that's 4!
+        # Host 4 → connects to host 5 (3 peers: 2,3,5)
+        # Host 5 → (2 peers: 3,4)
+
+        peer_counts = [len(pubsub.peers) for pubsub in pubsubs_fsub]
+
+        # First and last hosts should have exactly degree connections
+        assert peer_counts[0] == degree, (
+            f"Host 0 should have {degree} peers, got {peer_counts[0]}"
+        )
+        assert peer_counts[-1] <= degree, (
+            f"Last host should have ≤ {degree} peers, got {peer_counts[-1]}"
+        )
+
+        # Middle hosts may have more due to bidirectional connections
+        # but the pattern should be consistent with degree limit
+        total_connections = sum(peer_counts)
+
+        # Should be less than full mesh (each host connected to all others)
+        full_mesh_connections = len(hosts) * (len(hosts) - 1)
+        assert total_connections < full_mesh_connections, (
+            f"Got {total_connections} total connections, "
+            f"but full mesh would be {full_mesh_connections}"
+        )
+
+        # Should be more than just a chain (each host connected to next only)
+        chain_connections = 2 * (len(hosts) - 1)  # bidirectional chain
+        assert total_connections > chain_connections, (
+            f"Got {total_connections} total connections, which is too few "
+            f"(chain would be {chain_connections})"
+        )
+
+
+@pytest.mark.trio
+async def test_connect_some_degree_zero():
+    """Test edge case: degree=0 should result in no connections."""
+    # Create 5 hosts with degree=0
+    async with PubsubFactory.create_batch_with_floodsub(5) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+        degree = 0
+
+        await connect_some(hosts, degree)
+        await trio.sleep(0.1)  # Allow any potential connections to establish
+
+        # Verify no connections were made
+        for i, pubsub in enumerate(pubsubs_fsub):
+            connected_peers = len(pubsub.peers)
+            assert connected_peers == 0, (
+                f"Host {i} has {connected_peers} connections, "
+                f"but degree=0 should result in no connections"
+            )
+
+
+@pytest.mark.trio
+async def test_connect_some_negative_degree():
+    """Test edge case: negative degree should be handled gracefully."""
+    # Create 5 hosts with degree=-1
+    async with PubsubFactory.create_batch_with_floodsub(5) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+        degree = -1
+
+        await connect_some(hosts, degree)
+        await trio.sleep(0.1)  # Allow any potential connections to establish
+
+        # Verify no connections were made (negative degree should behave like 0)
+        for i, pubsub in enumerate(pubsubs_fsub):
+            connected_peers = len(pubsub.peers)
+            assert connected_peers == 0, (
+                f"Host {i} has {connected_peers} connections, "
+                f"but negative degree should result in no connections"
+            )
+
+
+@pytest.mark.trio
+async def test_sparse_connect_degree_zero():
+    """Test sparse_connect with degree=0."""
+    async with PubsubFactory.create_batch_with_floodsub(8) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+        degree = 0
+
+        await sparse_connect(hosts, degree)
+        await trio.sleep(0.1)  # Allow connections to establish
+
+        # With degree=0, sparse_connect should still create neighbor connections
+        # for connectivity (this is part of the algorithm design)
+        for i, pubsub in enumerate(pubsubs_fsub):
+            connected_peers = len(pubsub.peers)
+            # Should have some connections due to neighbor connectivity
+            # (each node connects to immediate neighbors)
+            expected_neighbors = 2  # previous and next in ring
+            assert connected_peers >= expected_neighbors, (
+                f"Host {i} has {connected_peers} connections, "
+                f"expected at least {expected_neighbors} neighbor connections"
+            )
+
+
+@pytest.mark.trio
+async def test_empty_host_list():
+    """Test edge case: empty host list should be handled gracefully."""
+    hosts = []
+
+    # All functions should handle empty lists gracefully
+    await connect_some(hosts, 5)
+    await sparse_connect(hosts, 3)
+    await dense_connect(hosts)
+
+    # If we reach here without exceptions, the test passes
+
+
+@pytest.mark.trio
+async def test_single_host():
+    """Test edge case: single host should be handled gracefully."""
+    async with PubsubFactory.create_batch_with_floodsub(1) as pubsubs_fsub:
+        hosts = [pubsub.host for pubsub in pubsubs_fsub]
+
+        # All functions should handle single host gracefully
+        await connect_some(hosts, 5)
+        await sparse_connect(hosts, 3)
+        await dense_connect(hosts)
+
+        # Single host should have no connections
+        connected_peers = len(pubsubs_fsub[0].peers)
+        assert connected_peers == 0, (
+            f"Single host has {connected_peers} connections, expected 0"
+        )

tests/discovery/mdns/test_broadcaster.py

@@ -0,0 +1,91 @@
+"""
+Unit tests for mDNS broadcaster component.
+"""
+
+from zeroconf import Zeroconf
+
+from libp2p.discovery.mdns.broadcaster import PeerBroadcaster
+from libp2p.peer.id import ID
+
+
+class TestPeerBroadcaster:
+    """Unit tests for PeerBroadcaster."""
+
+    def test_broadcaster_initialization(self):
+        """Test that broadcaster initializes correctly."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-peer._p2p._udp.local."
+        peer_id = (
+            "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN"  # String, not ID object
+        )
+        port = 8000
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port,
+        )
+
+        assert broadcaster.zeroconf == zeroconf
+        assert broadcaster.service_type == service_type
+        assert broadcaster.service_name == service_name
+        assert broadcaster.peer_id == peer_id
+        assert broadcaster.port == port
+
+        # Clean up
+        zeroconf.close()
+
+    def test_broadcaster_service_creation(self):
+        """Test that broadcaster creates valid service info."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-peer2._p2p._udp.local."
+        peer_id_obj = ID.from_base58("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN")
+        peer_id = str(peer_id_obj)  # Convert to string
+        port = 8000
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port,
+        )
+
+        # Verify service was created and registered
+        service_info = broadcaster.service_info
+        assert service_info is not None
+        assert service_info.type == service_type
+        assert service_info.name == service_name
+        assert service_info.port == port
+        assert b"id" in service_info.properties
+        assert service_info.properties[b"id"] == peer_id.encode()
+
+        # Clean up
+        zeroconf.close()
+
+    def test_broadcaster_start_stop(self):
+        """Test that broadcaster can start and stop correctly."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-start-stop._p2p._udp.local."
+        peer_id_obj = ID.from_base58("QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N")
+        peer_id = str(peer_id_obj)  # Convert to string
+        port = 8001
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port,
+        )
+
+        # Service should be registered
+        assert broadcaster.service_info is not None
+
+        # Clean up
+        zeroconf.close()

tests/discovery/mdns/test_listener.py

@@ -0,0 +1,114 @@
+"""
+Unit tests for mDNS listener component.
+"""
+
+import socket
+
+from zeroconf import ServiceInfo, Zeroconf
+
+from libp2p.abc import Multiaddr
+from libp2p.discovery.mdns.listener import PeerListener
+from libp2p.peer.id import ID
+from libp2p.peer.peerstore import PeerStore
+
+
+class TestPeerListener:
+    """Unit tests for PeerListener."""
+
+    def test_listener_initialization(self):
+        """Test that listener initializes correctly."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "local-peer._p2p._udp.local."
+
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+        )
+
+        assert listener.peerstore == peerstore
+        assert listener.zeroconf == zeroconf
+        assert listener.service_type == service_type
+        assert listener.service_name == service_name
+        assert listener.discovered_services == {}
+
+        # Clean up
+        listener.stop()
+        zeroconf.close()
+
+    def test_listener_extract_peer_info_success(self):
+        """Test successful PeerInfo extraction from ServiceInfo."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type="_p2p._udp.local.",
+            service_name="local._p2p._udp.local.",
+        )
+
+        # Create sample service info
+        sample_peer_id = ID.from_base58(
+            "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN"
+        )
+        hostname = socket.gethostname()
+        local_ip = "192.168.1.100"
+
+        sample_service_info = ServiceInfo(
+            type_="_p2p._udp.local.",
+            name="test-peer._p2p._udp.local.",
+            port=8000,
+            properties={b"id": str(sample_peer_id).encode()},
+            server=f"{hostname}.local.",
+            addresses=[socket.inet_aton(local_ip)],
+        )
+
+        peer_info = listener._extract_peer_info(sample_service_info)
+
+        assert peer_info is not None
+        assert isinstance(peer_info.peer_id, ID)
+        assert len(peer_info.addrs) > 0
+        assert all(isinstance(addr, Multiaddr) for addr in peer_info.addrs)
+
+        # Check that protocol is TCP since we always use TCP
+        assert "/tcp/" in str(peer_info.addrs[0])
+
+        # Clean up
+        listener.stop()
+        zeroconf.close()
+
+    def test_listener_extract_peer_info_invalid_id(self):
+        """Test PeerInfo extraction fails with invalid peer ID."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type="_p2p._udp.local.",
+            service_name="local._p2p._udp.local.",
+        )
+
+        # Create service info with invalid peer ID
+        hostname = socket.gethostname()
+        local_ip = "192.168.1.100"
+
+        service_info = ServiceInfo(
+            type_="_p2p._udp.local.",
+            name="invalid-peer._p2p._udp.local.",
+            port=8000,
+            properties={b"id": b"invalid_peer_id_format"},
+            server=f"{hostname}.local.",
+            addresses=[socket.inet_aton(local_ip)],
+        )
+
+        peer_info = listener._extract_peer_info(service_info)
+        assert peer_info is None
+
+        # Clean up
+        listener.stop()
+        zeroconf.close()

tests/discovery/mdns/test_mdns.py

@@ -0,0 +1,121 @@
+"""
+Comprehensive integration tests for mDNS discovery functionality.
+"""
+
+import socket
+
+from zeroconf import Zeroconf
+
+from libp2p.discovery.mdns.broadcaster import PeerBroadcaster
+from libp2p.discovery.mdns.listener import PeerListener
+from libp2p.peer.id import ID
+from libp2p.peer.peerstore import PeerStore
+
+
+class TestMDNSDiscovery:
+    """Comprehensive integration tests for mDNS peer discovery."""
+
+    def test_one_host_finds_another(self):
+        """Test that one host can find another host using mDNS."""
+        # Create two separate Zeroconf instances to simulate different hosts
+        host1_zeroconf = Zeroconf()
+        host2_zeroconf = Zeroconf()
+
+        try:
+            # Host 1: Set up as broadcaster (the host to be discovered)
+            host1_peer_id_obj = ID.from_base58(
+                "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN"
+            )
+            host1_peer_id = str(host1_peer_id_obj)  # Convert to string
+            host1_broadcaster = PeerBroadcaster(
+                zeroconf=host1_zeroconf,
+                service_type="_p2p._udp.local.",
+                service_name="host1._p2p._udp.local.",
+                peer_id=host1_peer_id,
+                port=8000,
+            )
+
+            # Host 2: Set up as listener (the host that discovers others)
+            host2_peerstore = PeerStore()
+            host2_listener = PeerListener(
+                peerstore=host2_peerstore,
+                zeroconf=host2_zeroconf,
+                service_type="_p2p._udp.local.",
+                service_name="host2._p2p._udp.local.",
+            )
+
+            # Host 1 registers its service for discovery
+            host1_broadcaster.register()
+
+            # Verify that host2 discovered host1
+            assert len(host2_listener.discovered_services) > 0
+            assert "host1._p2p._udp.local." in host2_listener.discovered_services
+
+            # Verify that host1's peer info was added to host2's peerstore
+            discovered_peer_id = host2_listener.discovered_services[
+                "host1._p2p._udp.local."
+            ]
+            assert str(discovered_peer_id) == host1_peer_id
+
+            # Verify addresses were added to peerstore
+            try:
+                addrs = host2_peerstore.addrs(discovered_peer_id)
+                assert len(addrs) > 0
+                # Should be TCP since we always use TCP protocol
+                assert "/tcp/8000" in str(addrs[0])
+            except Exception:
+                # If no addresses found, the discovery didn't work properly
+                assert False, "Host1 addresses should be in Host2's peerstore"
+
+            # Clean up
+            host1_broadcaster.unregister()
+            host2_listener.stop()
+
+        finally:
+            host1_zeroconf.close()
+            host2_zeroconf.close()
+
+    def test_service_info_extraction(self):
+        """Test service info extraction functionality."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+
+        try:
+            listener = PeerListener(
+                peerstore=peerstore,
+                zeroconf=zeroconf,
+                service_type="_p2p._udp.local.",
+                service_name="test-listener._p2p._udp.local.",
+            )
+
+            # Create a test service info
+            test_peer_id = ID.from_base58(
+                "QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N"
+            )
+            hostname = socket.gethostname()
+
+            from zeroconf import ServiceInfo
+
+            service_info = ServiceInfo(
+                type_="_p2p._udp.local.",
+                name="test-service._p2p._udp.local.",
+                port=8001,
+                properties={b"id": str(test_peer_id).encode()},
+                server=f"{hostname}.local.",
+                addresses=[socket.inet_aton("192.168.1.100")],
+            )
+
+            # Test extraction
+            peer_info = listener._extract_peer_info(service_info)
+
+            assert peer_info is not None
+            assert peer_info.peer_id == test_peer_id
+            assert len(peer_info.addrs) == 1
+            assert "/tcp/8001" in str(peer_info.addrs[0])
+
+            print("✅ Service info extraction test successful!")
+            print(f"   Extracted peer ID: {peer_info.peer_id}")
+            print(f"   Extracted addresses: {[str(addr) for addr in peer_info.addrs]}")
+
+        finally:
+            zeroconf.close()

tests/discovery/mdns/test_utils.py

@@ -0,0 +1,39 @@
+"""
+Basic unit tests for mDNS utils module.
+"""
+
+import string
+
+from libp2p.discovery.mdns.utils import stringGen
+
+
+class TestStringGen:
+    """Unit tests for stringGen function."""
+
+    def test_stringgen_default_length(self):
+        """Test stringGen with default length (63)."""
+        result = stringGen()
+
+        assert isinstance(result, str)
+        assert len(result) == 63
+
+        # Check that all characters are from the expected charset
+        charset = string.ascii_lowercase + string.digits
+        for char in result:
+            assert char in charset
+
+    def test_stringgen_custom_length(self):
+        """Test stringGen with custom lengths."""
+        # Test various lengths
+        test_lengths = [1, 5, 10, 20, 50, 100]
+
+        for length in test_lengths:
+            result = stringGen(length)
+
+            assert isinstance(result, str)
+            assert len(result) == length
+
+            # Check that all characters are from the expected charset
+            charset = string.ascii_lowercase + string.digits
+            for char in result:
+                assert char in charset

tests/utils/pubsub/utils.py

@@ -24,16 +24,22 @@ def make_pubsub_msg(
     )
 
 
-# TODO: Implement sparse connect
 async def dense_connect(hosts: Sequence[IHost]) -> None:
     await connect_some(hosts, 10)
 
 
-# FIXME: `degree` is not used at all
 async def connect_some(hosts: Sequence[IHost], degree: int) -> None:
+    """
+    Connect each host to up to 'degree' number of other hosts.
+    Creates a sparse network topology where each node has limited connections.
+    """
     for i, host in enumerate(hosts):
-        for host2 in hosts[i + 1 :]:
-            await connect(host, host2)
+        connections_made = 0
+        for j in range(i + 1, len(hosts)):
+            if connections_made >= degree:
+                break
+            await connect(host, hosts[j])
+            connections_made += 1
 
 
 async def one_to_all_connect(hosts: Sequence[IHost], central_host_index: int) -> None:

tests/utils/utils.py

@@ -0,0 +1,14 @@
+from unittest.mock import (
+    MagicMock,
+)
+
+
+def create_mock_connections() -> dict:
+    connections = {}
+
+    for i in range(1, 31):
+        peer_id = f"peer-{i}"
+        mock_conn = MagicMock(name=f"INetConn-{i}")
+        connections[peer_id] = mock_conn
+
+    return connections