libp2p 0.2.6__tar.gz → 0.2.7__tar.gz

{libp2p-0.2.6/libp2p.egg-info → libp2p-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libp2p
-Version: 0.2.6
+Version: 0.2.7
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation

{libp2p-0.2.6 → libp2p-0.2.7}/examples/identify_push/identify_push_demo.py

@@ -85,6 +85,52 @@ async def main() -> None:
         logger.info("Host 2 connected to Host 1")
         print("Host 2 successfully connected to Host 1")
 
+        # Run the identify protocol from host_2 to host_1
+        # (so Host 1 learns Host 2's address)
+        from libp2p.identity.identify.identify import ID as IDENTIFY_PROTOCOL_ID
+
+        stream = await host_2.new_stream(host_1.get_id(), (IDENTIFY_PROTOCOL_ID,))
+        response = await stream.read()
+        await stream.close()
+
+        # Run the identify protocol from host_1 to host_2
+        # (so Host 2 learns Host 1's address)
+        stream = await host_1.new_stream(host_2.get_id(), (IDENTIFY_PROTOCOL_ID,))
+        response = await stream.read()
+        await stream.close()
+
+        # --- NEW CODE: Update Host 1's peerstore with Host 2's addresses ---
+        from libp2p.identity.identify.pb.identify_pb2 import (
+            Identify,
+        )
+
+        identify_msg = Identify()
+        identify_msg.ParseFromString(response)
+        peerstore_1 = host_1.get_peerstore()
+        peer_id_2 = host_2.get_id()
+        for addr_bytes in identify_msg.listen_addrs:
+            maddr = multiaddr.Multiaddr(addr_bytes)
+            # TTL can be any positive int
+            peerstore_1.add_addr(
+                peer_id_2,
+                maddr,
+                ttl=3600,
+            )
+        # --- END NEW CODE ---
+
+        # Now Host 1's peerstore should have Host 2's address
+        peerstore_1 = host_1.get_peerstore()
+        peer_id_2 = host_2.get_id()
+        addrs_1_for_2 = peerstore_1.addrs(peer_id_2)
+        logger.info(
+            f"[DEBUG] Host 1 peerstore addresses for Host 2 before push: "
+            f"{addrs_1_for_2}"
+        )
+        print(
+            f"[DEBUG] Host 1 peerstore addresses for Host 2 before push: "
+            f"{addrs_1_for_2}"
+        )
+
         # Push identify information from host_1 to host_2
         logger.info("Host 1 pushing identify information to Host 2")
         print("\nHost 1 pushing identify information to Host 2...")
@@ -104,6 +150,9 @@ async def main() -> None:
             logger.error(f"Error during identify push: {str(e)}")
             print(f"\nError during identify push: {str(e)}")
 
+        # Add this at the end of your async with block:
+        await trio.sleep(0.5)  # Give background tasks time to finish
+
 
 if __name__ == "__main__":
     trio.run(main)

libp2p-0.2.7/libp2p/__init__.py

@@ -0,0 +1,257 @@
+from collections.abc import (
+    Mapping,
+)
+from importlib.metadata import version as __version
+from typing import (
+    Literal,
+    Optional,
+    Type,
+    cast,
+)
+
+from libp2p.abc import (
+    IHost,
+    IMuxedConn,
+    INetworkService,
+    IPeerRouting,
+    IPeerStore,
+    ISecureTransport,
+)
+from libp2p.crypto.keys import (
+    KeyPair,
+)
+from libp2p.crypto.rsa import (
+    create_new_key_pair,
+)
+from libp2p.crypto.x25519 import create_new_key_pair as create_new_x25519_key_pair
+from libp2p.custom_types import (
+    TMuxerOptions,
+    TProtocol,
+    TSecurityOptions,
+)
+from libp2p.host.basic_host import (
+    BasicHost,
+)
+from libp2p.host.routed_host import (
+    RoutedHost,
+)
+from libp2p.network.swarm import (
+    Swarm,
+)
+from libp2p.peer.id import (
+    ID,
+)
+from libp2p.peer.peerstore import (
+    PeerStore,
+)
+from libp2p.security.insecure.transport import (
+    PLAINTEXT_PROTOCOL_ID,
+    InsecureTransport,
+)
+from libp2p.security.noise.transport import PROTOCOL_ID as NOISE_PROTOCOL_ID
+from libp2p.security.noise.transport import Transport as NoiseTransport
+import libp2p.security.secio.transport as secio
+from libp2p.stream_muxer.mplex.mplex import (
+    MPLEX_PROTOCOL_ID,
+    Mplex,
+)
+from libp2p.stream_muxer.yamux.yamux import (
+    Yamux,
+)
+from libp2p.stream_muxer.yamux.yamux import PROTOCOL_ID as YAMUX_PROTOCOL_ID
+from libp2p.transport.tcp.tcp import (
+    TCP,
+)
+from libp2p.transport.upgrader import (
+    TransportUpgrader,
+)
+from libp2p.utils.logging import (
+    setup_logging,
+)
+
+# Initialize logging configuration
+setup_logging()
+
+# Default multiplexer choice
+DEFAULT_MUXER = "YAMUX"
+
+# Multiplexer options
+MUXER_YAMUX = "YAMUX"
+MUXER_MPLEX = "MPLEX"
+
+
+def set_default_muxer(muxer_name: Literal["YAMUX", "MPLEX"]) -> None:
+    """
+    Set the default multiplexer protocol to use.
+
+    :param muxer_name: Either "YAMUX" or "MPLEX"
+    :raise ValueError: If an unsupported muxer name is provided
+    """
+    global DEFAULT_MUXER
+    muxer_upper = muxer_name.upper()
+    if muxer_upper not in [MUXER_YAMUX, MUXER_MPLEX]:
+        raise ValueError(f"Unknown muxer: {muxer_name}. Use 'YAMUX' or 'MPLEX'.")
+    DEFAULT_MUXER = muxer_upper
+
+
+def get_default_muxer() -> str:
+    """
+    Returns the currently selected default muxer.
+
+    :return: Either "YAMUX" or "MPLEX"
+    """
+    return DEFAULT_MUXER
+
+
+def create_yamux_muxer_option() -> TMuxerOptions:
+    """
+    Returns muxer options with Yamux as the primary choice.
+
+    :return: Muxer options with Yamux first
+    """
+    return {
+        TProtocol(YAMUX_PROTOCOL_ID): Yamux,  # Primary choice
+        TProtocol(MPLEX_PROTOCOL_ID): Mplex,  # Fallback for compatibility
+    }
+
+
+def create_mplex_muxer_option() -> TMuxerOptions:
+    """
+    Returns muxer options with Mplex as the primary choice.
+
+    :return: Muxer options with Mplex first
+    """
+    return {
+        TProtocol(MPLEX_PROTOCOL_ID): Mplex,  # Primary choice
+        TProtocol(YAMUX_PROTOCOL_ID): Yamux,  # Fallback
+    }
+
+
+def generate_new_rsa_identity() -> KeyPair:
+    return create_new_key_pair()
+
+
+def generate_peer_id_from(key_pair: KeyPair) -> ID:
+    public_key = key_pair.public_key
+    return ID.from_pubkey(public_key)
+
+
+def get_default_muxer_options() -> TMuxerOptions:
+    """
+    Returns the default muxer options based on the current default muxer setting.
+
+    :return: Muxer options with the preferred muxer first
+    """
+    if DEFAULT_MUXER == "MPLEX":
+        return create_mplex_muxer_option()
+    else:  # YAMUX is default
+        return create_yamux_muxer_option()
+
+
+def new_swarm(
+    key_pair: Optional[KeyPair] = None,
+    muxer_opt: Optional[TMuxerOptions] = None,
+    sec_opt: Optional[TSecurityOptions] = None,
+    peerstore_opt: Optional[IPeerStore] = None,
+    muxer_preference: Optional[Literal["YAMUX", "MPLEX"]] = None,
+) -> INetworkService:
+    """
+    Create a swarm instance based on the parameters.
+
+    :param key_pair: optional choice of the ``KeyPair``
+    :param muxer_opt: optional choice of stream muxer
+    :param sec_opt: optional choice of security upgrade
+    :param peerstore_opt: optional peerstore
+    :param muxer_preference: optional explicit muxer preference
+    :return: return a default swarm instance
+
+    Note: Yamux (/yamux/1.0.0) is the preferred stream multiplexer
+          due to its improved performance and features.
+          Mplex (/mplex/6.7.0) is retained for backward compatibility
+          but may be deprecated in the future.
+    """
+    if key_pair is None:
+        key_pair = generate_new_rsa_identity()
+
+    id_opt = generate_peer_id_from(key_pair)
+
+    # TODO: Parse `listen_addrs` to determine transport
+    transport = TCP()
+
+    # Generate X25519 keypair for Noise
+    noise_key_pair = create_new_x25519_key_pair()
+
+    # Default security transports (using Noise as primary)
+    secure_transports_by_protocol: Mapping[TProtocol, ISecureTransport] = sec_opt or {
+        NOISE_PROTOCOL_ID: NoiseTransport(
+            key_pair, noise_privkey=noise_key_pair.private_key
+        ),
+        TProtocol(secio.ID): secio.Transport(key_pair),
+        TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair),
+    }
+
+    # Use given muxer preference if provided, otherwise use global default
+    if muxer_preference is not None:
+        temp_pref = muxer_preference.upper()
+        if temp_pref not in [MUXER_YAMUX, MUXER_MPLEX]:
+            raise ValueError(
+                f"Unknown muxer: {muxer_preference}. Use 'YAMUX' or 'MPLEX'."
+            )
+        active_preference = temp_pref
+    else:
+        active_preference = DEFAULT_MUXER
+
+    # Use provided muxer options if given, otherwise create based on preference
+    if muxer_opt is not None:
+        muxer_transports_by_protocol = muxer_opt
+    else:
+        if active_preference == MUXER_MPLEX:
+            muxer_transports_by_protocol = create_mplex_muxer_option()
+        else:  # YAMUX is default
+            muxer_transports_by_protocol = create_yamux_muxer_option()
+
+    upgrader = TransportUpgrader(
+        secure_transports_by_protocol=secure_transports_by_protocol,
+        muxer_transports_by_protocol=muxer_transports_by_protocol,
+    )
+
+    peerstore = peerstore_opt or PeerStore()
+    # Store our key pair in peerstore
+    peerstore.add_key_pair(id_opt, key_pair)
+
+    return Swarm(id_opt, peerstore, upgrader, transport)
+
+
+def new_host(
+    key_pair: Optional[KeyPair] = None,
+    muxer_opt: Optional[TMuxerOptions] = None,
+    sec_opt: Optional[TSecurityOptions] = None,
+    peerstore_opt: Optional[IPeerStore] = None,
+    disc_opt: Optional[IPeerRouting] = None,
+    muxer_preference: Optional[Literal["YAMUX", "MPLEX"]] = None,
+) -> IHost:
+    """
+    Create a new libp2p host based on the given parameters.
+
+    :param key_pair: optional choice of the ``KeyPair``
+    :param muxer_opt: optional choice of stream muxer
+    :param sec_opt: optional choice of security upgrade
+    :param peerstore_opt: optional peerstore
+    :param disc_opt: optional discovery
+    :param muxer_preference: optional explicit muxer preference
+    :return: return a host instance
+    """
+    swarm = new_swarm(
+        key_pair=key_pair,
+        muxer_opt=muxer_opt,
+        sec_opt=sec_opt,
+        peerstore_opt=peerstore_opt,
+        muxer_preference=muxer_preference,
+    )
+
+    if disc_opt is not None:
+        return RoutedHost(swarm, disc_opt)
+    return BasicHost(swarm)
+
+
+__version__ = __version("libp2p")

{libp2p-0.2.6 → libp2p-0.2.7}/libp2p/crypto/keys.py

@@ -1,3 +1,5 @@
+"""Key types and interfaces."""
+
 from abc import (
     ABC,
     abstractmethod,
@@ -9,17 +11,24 @@ from enum import (
     Enum,
     unique,
 )
+from typing import (
+    cast,
+)
 
-from .pb import crypto_pb2 as protobuf
+from libp2p.crypto.pb import (
+    crypto_pb2,
+)
 
 
 @unique
 class KeyType(Enum):
-    RSA = protobuf.KeyType.RSA
-    Ed25519 = protobuf.KeyType.Ed25519
-    Secp256k1 = protobuf.KeyType.Secp256k1
-    ECDSA = protobuf.KeyType.ECDSA
-    ECC_P256 = protobuf.KeyType.ECC_P256
+    RSA = crypto_pb2.KeyType.RSA
+    Ed25519 = crypto_pb2.KeyType.Ed25519
+    Secp256k1 = crypto_pb2.KeyType.Secp256k1
+    ECDSA = crypto_pb2.KeyType.ECDSA
+    ECC_P256 = crypto_pb2.KeyType.ECC_P256
+    # X25519 is added for Noise protocol
+    X25519 = cast(crypto_pb2.KeyType.ValueType, 5)
 
 
 class Key(ABC):
@@ -52,11 +61,11 @@ class PublicKey(Key):
         """
         ...
 
-    def _serialize_to_protobuf(self) -> protobuf.PublicKey:
+    def _serialize_to_protobuf(self) -> crypto_pb2.PublicKey:
         """Return the protobuf representation of this ``Key``."""
         key_type = self.get_type().value
         data = self.to_bytes()
-        protobuf_key = protobuf.PublicKey(key_type=key_type, data=data)
+        protobuf_key = crypto_pb2.PublicKey(key_type=key_type, data=data)
         return protobuf_key
 
     def serialize(self) -> bytes:
@@ -64,8 +73,8 @@ class PublicKey(Key):
         return self._serialize_to_protobuf().SerializeToString()
 
     @classmethod
-    def deserialize_from_protobuf(cls, protobuf_data: bytes) -> protobuf.PublicKey:
-        return protobuf.PublicKey.FromString(protobuf_data)
+    def deserialize_from_protobuf(cls, protobuf_data: bytes) -> crypto_pb2.PublicKey:
+        return crypto_pb2.PublicKey.FromString(protobuf_data)
 
 
 class PrivateKey(Key):
@@ -79,11 +88,11 @@ class PrivateKey(Key):
     def get_public_key(self) -> PublicKey:
         ...
 
-    def _serialize_to_protobuf(self) -> protobuf.PrivateKey:
+    def _serialize_to_protobuf(self) -> crypto_pb2.PrivateKey:
         """Return the protobuf representation of this ``Key``."""
         key_type = self.get_type().value
         data = self.to_bytes()
-        protobuf_key = protobuf.PrivateKey(key_type=key_type, data=data)
+        protobuf_key = crypto_pb2.PrivateKey(key_type=key_type, data=data)
         return protobuf_key
 
     def serialize(self) -> bytes:
@@ -91,8 +100,8 @@ class PrivateKey(Key):
         return self._serialize_to_protobuf().SerializeToString()
 
     @classmethod
-    def deserialize_from_protobuf(cls, protobuf_data: bytes) -> protobuf.PrivateKey:
-        return protobuf.PrivateKey.FromString(protobuf_data)
+    def deserialize_from_protobuf(cls, protobuf_data: bytes) -> crypto_pb2.PrivateKey:
+        return crypto_pb2.PrivateKey.FromString(protobuf_data)
 
 
 @dataclass(frozen=True)

libp2p-0.2.7/libp2p/crypto/x25519.py

@@ -0,0 +1,69 @@
+from cryptography.hazmat.primitives import (
+    serialization,
+)
+from cryptography.hazmat.primitives.asymmetric import (
+    x25519,
+)
+
+from libp2p.crypto.keys import (
+    KeyPair,
+    KeyType,
+    PrivateKey,
+    PublicKey,
+)
+
+
+class X25519PublicKey(PublicKey):
+    def __init__(self, impl: x25519.X25519PublicKey) -> None:
+        self.impl = impl
+
+    def to_bytes(self) -> bytes:
+        return self.impl.public_bytes(
+            encoding=serialization.Encoding.Raw, format=serialization.PublicFormat.Raw
+        )
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "X25519PublicKey":
+        return cls(x25519.X25519PublicKey.from_public_bytes(data))
+
+    def get_type(self) -> KeyType:
+        # Not in protobuf, but for Noise use only
+        return KeyType.X25519  # Or define KeyType.X25519 if you want to extend
+
+    def verify(self, data: bytes, signature: bytes) -> bool:
+        raise NotImplementedError("X25519 does not support signatures.")
+
+
+class X25519PrivateKey(PrivateKey):
+    def __init__(self, impl: x25519.X25519PrivateKey) -> None:
+        self.impl = impl
+
+    @classmethod
+    def new(cls) -> "X25519PrivateKey":
+        return cls(x25519.X25519PrivateKey.generate())
+
+    def to_bytes(self) -> bytes:
+        return self.impl.private_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PrivateFormat.Raw,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "X25519PrivateKey":
+        return cls(x25519.X25519PrivateKey.from_private_bytes(data))
+
+    def get_type(self) -> KeyType:
+        return KeyType.X25519
+
+    def sign(self, data: bytes) -> bytes:
+        raise NotImplementedError("X25519 does not support signatures.")
+
+    def get_public_key(self) -> PublicKey:
+        return X25519PublicKey(self.impl.public_key())
+
+
+def create_new_key_pair() -> KeyPair:
+    priv = X25519PrivateKey.new()
+    pub = priv.get_public_key()
+    return KeyPair(priv, pub)

libp2p-0.2.7/libp2p/exceptions.py

@@ -0,0 +1,53 @@
+from collections.abc import (
+    Sequence,
+)
+
+
+class BaseLibp2pError(Exception):
+    pass
+
+
+class ValidationError(BaseLibp2pError):
+    """Raised when something does not pass a validation check."""
+
+
+class ParseError(BaseLibp2pError):
+    pass
+
+
+class MultiError(BaseLibp2pError):
+    r"""
+    A combined error that wraps multiple exceptions into a single error object.
+    This error is raised when multiple exceptions need to be reported together,
+    typically in scenarios where parallel operations or multiple validations fail.
+
+    Example\:
+    ---------
+        >>> from libp2p.exceptions import MultiError
+        >>> errors = [
+        ...     ValueError("Invalid input"),
+        ...     TypeError("Wrong type"),
+        ...     RuntimeError("Operation failed")
+        ... ]
+        >>> multi_error = MultiError(errors)
+        >>> print(multi_error)
+        Error 1: Invalid input
+        Error 2: Wrong type
+        Error 3: Operation failed
+
+    Note\:
+    ------
+        The string representation of this error will number and list all contained
+        errors sequentially, making it easier to identify individual issues in
+        complex error scenarios.
+
+    """
+
+    def __init__(self, errors: Sequence[Exception]) -> None:
+        super().__init__(errors)
+        self.errors = errors  # Storing list of errors
+
+    def __str__(self) -> str:
+        return "\n".join(
+            f"Error {i + 1}: {error}" for i, error in enumerate(self.errors)
+        )

{libp2p-0.2.6 → libp2p-0.2.7}/libp2p/network/connection/swarm_connection.py

@@ -1,3 +1,4 @@
+import logging
 from typing import (
     TYPE_CHECKING,
 )
@@ -37,30 +38,69 @@ class SwarmConn(INetConn):
         self.streams = set()
         self.event_closed = trio.Event()
         self.event_started = trio.Event()
+        if hasattr(muxed_conn, "on_close"):
+            logging.debug(f"Setting on_close for peer {muxed_conn.peer_id}")
+            muxed_conn.on_close = self._on_muxed_conn_closed
+        else:
+            logging.error(
+                f"muxed_conn for peer {muxed_conn.peer_id} has no on_close attribute"
+            )
 
     @property
     def is_closed(self) -> bool:
         return self.event_closed.is_set()
 
+    async def _on_muxed_conn_closed(self) -> None:
+        """Handle closure of the underlying muxed connection."""
+        peer_id = self.muxed_conn.peer_id
+        logging.debug(f"SwarmConn closing for peer {peer_id} due to muxed_conn closure")
+        # Only call close if we're not already closing
+        if not self.event_closed.is_set():
+            await self.close()
+
     async def close(self) -> None:
         if self.event_closed.is_set():
             return
+        logging.debug(f"Closing SwarmConn for peer {self.muxed_conn.peer_id}")
         self.event_closed.set()
+
+        # Close the muxed connection
+        try:
+            await self.muxed_conn.close()
+        except Exception as e:
+            logging.warning(f"Error while closing muxed connection: {e}")
+
+        # Perform proper cleanup of resources
         await self._cleanup()
 
     async def _cleanup(self) -> None:
+        # Remove the connection from swarm
+        logging.debug(f"Removing connection for peer {self.muxed_conn.peer_id}")
         self.swarm.remove_conn(self)
 
-        await self.muxed_conn.close()
+        # Only close the connection if it's not already closed
+        # Be defensive here to avoid exceptions during cleanup
+        try:
+            if not self.muxed_conn.is_closed:
+                await self.muxed_conn.close()
+        except Exception as e:
+            logging.warning(f"Error closing muxed connection: {e}")
 
         # This is just for cleaning up state. The connection has already been closed.
         # We *could* optimize this but it really isn't worth it.
+        logging.debug(f"Resetting streams for peer {self.muxed_conn.peer_id}")
         for stream in self.streams.copy():
-            await stream.reset()
+            try:
+                await stream.reset()
+            except Exception as e:
+                logging.warning(f"Error resetting stream: {e}")
+
         # Force context switch for stream handlers to process the stream reset event we
         # just emit before we cancel the stream handler tasks.
         await trio.sleep(0.1)
 
+        # Notify all listeners about the disconnection
+        logging.debug(f"Notifying disconnection for peer {self.muxed_conn.peer_id}")
         await self._notify_disconnected()
 
     async def _handle_new_streams(self) -> None:

{libp2p-0.2.6 → libp2p-0.2.7}/libp2p/network/stream/net_stream.py

@@ -12,6 +12,7 @@ from libp2p.custom_types import (
 from libp2p.stream_muxer.exceptions import (
     MuxedStreamClosed,
     MuxedStreamEOF,
+    MuxedStreamError,
     MuxedStreamReset,
 )
 
@@ -68,7 +69,7 @@ class NetStream(INetStream):
         """
         try:
             await self.muxed_stream.write(data)
-        except MuxedStreamClosed as error:
+        except (MuxedStreamClosed, MuxedStreamError) as error:
             raise StreamClosed() from error
 
     async def close(self) -> None:

{libp2p-0.2.6 → libp2p-0.2.7}/libp2p/network/swarm.py

@@ -313,7 +313,35 @@ class Swarm(Service, INetworkService):
         return False
 
     async def close(self) -> None:
-        await self.manager.stop()
+        """
+        Close the swarm instance and cleanup resources.
+        """
+        # Check if manager exists before trying to stop it
+        if hasattr(self, "_manager") and self._manager is not None:
+            await self._manager.stop()
+        else:
+            # Perform alternative cleanup if the manager isn't initialized
+            # Close all connections manually
+            if hasattr(self, "connections"):
+                for conn_id in list(self.connections.keys()):
+                    conn = self.connections[conn_id]
+                    await conn.close()
+
+                # Clear connection tracking dictionary
+                self.connections.clear()
+
+            # Close all listeners
+            if hasattr(self, "listeners"):
+                for listener in self.listeners.values():
+                    await listener.close()
+                self.listeners.clear()
+
+            # Close the transport if it exists and has a close method
+            if hasattr(self, "transport") and self.transport is not None:
+                # Check if transport has close method before calling it
+                if hasattr(self.transport, "close"):
+                    await self.transport.close()
+
         logger.debug("swarm successfully closed")
 
     async def close_peer(self, peer_id: ID) -> None:

{libp2p-0.2.6 → libp2p-0.2.7}/libp2p/peer/peerstore.py

@@ -4,6 +4,7 @@ from collections import (
 from collections.abc import (
     Sequence,
 )
+import sys
 from typing import (
     Any,
 )
@@ -32,6 +33,8 @@ from .peerinfo import (
     PeerInfo,
 )
 
+PERMANENT_ADDR_TTL = sys.maxsize
+
 
 class PeerStore(IPeerStore):
     peer_data_map: dict[ID, PeerData]