libp2p.transport package

Subpackages

Submodules

libp2p.transport.exceptions module

exception libp2p.transport.exceptions.MuxerUpgradeFailure: Bases: UpgradeFailure

exception libp2p.transport.exceptions.OpenConnectionError: Bases: BaseLibp2pError

exception libp2p.transport.exceptions.SecurityUpgradeFailure: Bases: UpgradeFailure

exception libp2p.transport.exceptions.UpgradeFailure: Bases: BaseLibp2pError

libp2p.transport.upgrader module

class libp2p.transport.upgrader.TransportUpgrader(secure_transports_by_protocol: Mapping[TProtocol, object], muxer_transports_by_protocol: Mapping[TProtocol, type[object]], negotiate_timeout: int = 30)

Bases: object

muxer_multistream: MuxerMultistream

security_multistream: SecurityMultistream

async upgrade_connection(conn: ISecureConn, peer_id: ID) → IMuxedConn: Upgrade secured connection to a muxed connection.

async upgrade_security(raw_conn: IRawConnection, is_initiator: bool, peer_id: ID | None = None) → ISecureConn: Upgrade conn to a secured connection.

Module contents

class libp2p.transport.TCP

Bases: ITransport

create_listener(handler_function: Callable[[ReadWriteCloser], Awaitable[None]]) → TCPListener

Create listener on transport.

Parameters:: handler_function – a function called when a new connection is received that takes a connection as argument which implements interface-connection
Returns:: a listener object that implements listener_interface.py

async dial(maddr: Multiaddr) → IRawConnection

Dial a transport to peer listening on multiaddr.

Parameters:: maddr – multiaddr of peer
Returns:: RawConnection if successful
Raises:: OpenConnectionError – raised when failed to open connection

class libp2p.transport.TransportRegistry

Bases: object

Registry for mapping multiaddr protocols to transport implementations.

create_transport(protocol: str, upgrader: TransportUpgrader | None = None, **kwargs: Any) → ITransport | None

Create a transport instance for a specific protocol.

Parameters:

protocol – The protocol identifier
upgrader – The transport upgrader instance (required for WebSocket)
kwargs – Additional arguments for transport construction

Returns:

Transport instance or None if protocol not supported or creation fails

get_supported_protocols() → list[str]: Get list of supported transport protocols.

get_transport(protocol: str) → type[ITransport] | None

Get the transport class for a specific protocol.

Parameters:: protocol – The protocol identifier
Returns:: The transport class or None if not found

register_transport(protocol: str, transport_class: type[ITransport]) → None

Register a transport class for a specific protocol.

Parameters:

protocol – The protocol identifier (e.g., “tcp”, “ws”)
transport_class – The transport class to register

class libp2p.transport.WebsocketTransport(upgrader: TransportUpgrader, config: WebsocketConfig | None = None, tls_client_config: SSLContext | None = None, tls_server_config: SSLContext | None = None, handshake_timeout: float | None = None)

Bases: ITransport

Libp2p WebSocket transport implementation with production features:

Features: - WS and WSS protocol support with configurable TLS - Connection management with limits and tracking - Flow control and buffer management - SOCKS5 proxy support - Proper error handling and connection cleanup - Configurable timeouts and limits - Connection state monitoring - Concurrent connection handling

async can_dial(maddr: Multiaddr) → bool: Check if we can dial the given multiaddr.

create_listener(handler: Callable[[ReadWriteCloser], Awaitable[None]]) → IListener

Create a WebSocket listener with the given handler.

Args:: handler: Connection handler function
Returns:: A WebSocket listener

Raises:: ValueError – If configuration validation fails

async dial(maddr: Multiaddr) → RawConnection

Dial a WebSocket connection to the given multiaddr.

Args:: maddr: The multiaddr to dial (e.g., /ip4/127.0.0.1/tcp/8000/ws)
Returns:: An upgraded RawConnection

Raises:

OpenConnectionError – If connection fails, cannot dial the multiaddr, connection upgrade fails, or maximum connections reached
ValueError – If multiaddr is invalid or cannot be parsed

async get_connections() → dict[str, P2PWebSocketConnection]: Get all active connections.

get_listeners() → set[WebsocketListener]: Get all active listeners.

get_stats() → dict[str, int]: Get transport statistics.

resolve(maddr: Multiaddr) → list[Multiaddr]

Resolve a WebSocket multiaddr to its concrete addresses. Currently, just validates and returns the input multiaddr.

Args:: maddr: The multiaddr to resolve
Returns:: List containing the original multiaddr

set_background_nursery(nursery: Nursery) → None: Set the nursery to use for background tasks (called by Swarm).

set_peer_id(peer_id: ID) → None: Set the peer ID of the host.

libp2p.transport.create_transport(protocol: str, upgrader: TransportUpgrader | None = None, **kwargs: Any) → ITransport

Convenience function to create a transport instance.

Parameters:

protocol – The transport protocol (“tcp”, “ws”, “wss”, or custom)
upgrader – Optional transport upgrader (required for WebSocket)
kwargs – Additional arguments for transport construction (e.g., tls_client_config, tls_server_config)

Returns:

Transport instance

libp2p.transport.create_transport_for_multiaddr(maddr: Multiaddr, upgrader: TransportUpgrader, **kwargs: Any) → ITransport | None

Create the appropriate transport for a given multiaddr.

Parameters:

maddr – The multiaddr to create transport for
upgrader – The transport upgrader instance
kwargs – Additional arguments for transport construction (e.g., private_key for QUIC)

Returns:

Transport instance or None if no suitable transport found

libp2p.transport.get_supported_transport_protocols() → list[str]: Get list of supported transport protocols from the global registry.

libp2p.transport.get_transport_registry() → TransportRegistry: Get the global transport registry instance.

libp2p.transport.register_transport(protocol: str, transport_class: type[ITransport]) → None: Register a transport class in the global registry.