libp2p package

Subpackages

• libp2p.crypto package
  • Subpackages
    • libp2p.crypto.pb package
      • Submodules
      • libp2p.crypto.pb.crypto_pb2 module
      • Module contents
  • Submodules
  • libp2p.crypto.authenticated_encryption module
    • EncryptionParameters
      • EncryptionParameters.cipher_key
      • EncryptionParameters.cipher_type
      • EncryptionParameters.hash_type
      • EncryptionParameters.iv
      • EncryptionParameters.mac_key
    • InvalidMACException
    • MacAndCipher
      • MacAndCipher.authenticate()
      • MacAndCipher.decrypt_if_valid()
      • MacAndCipher.encrypt()
    • initialize_pair()
  • libp2p.crypto.ecc module
    • ECCPrivateKey
      • ECCPrivateKey.get_public_key()
      • ECCPrivateKey.get_type()
      • ECCPrivateKey.new()
      • ECCPrivateKey.sign()
      • ECCPrivateKey.to_bytes()
    • ECCPublicKey
      • ECCPublicKey.from_bytes()
      • ECCPublicKey.get_type()
      • ECCPublicKey.to_bytes()
      • ECCPublicKey.verify()
    • create_new_key_pair()
    • infer_local_type()
  • libp2p.crypto.ed25519 module
    • Ed25519PrivateKey
      • Ed25519PrivateKey.from_bytes()
      • Ed25519PrivateKey.get_public_key()
      • Ed25519PrivateKey.get_type()
      • Ed25519PrivateKey.new()
      • Ed25519PrivateKey.sign()
      • Ed25519PrivateKey.to_bytes()
    • Ed25519PublicKey
      • Ed25519PublicKey.from_bytes()
      • Ed25519PublicKey.get_type()
      • Ed25519PublicKey.to_bytes()
      • Ed25519PublicKey.verify()
    • create_new_key_pair()
  • libp2p.crypto.exceptions module
    • CryptographyError
    • MissingDeserializerError
  • libp2p.crypto.key_exchange module
    • create_ephemeral_key_pair()
  • libp2p.crypto.keys module
    • Key
      • Key.get_type()
      • Key.to_bytes()
    • KeyPair
      • KeyPair.private_key
      • KeyPair.public_key
    • KeyType
      • KeyType.ECC_P256
      • KeyType.ECDSA
      • KeyType.Ed25519
      • KeyType.RSA
      • KeyType.Secp256k1
    • PrivateKey
      • PrivateKey.deserialize_from_protobuf()
      • PrivateKey.get_public_key()
      • PrivateKey.serialize()
      • PrivateKey.sign()
    • PublicKey
      • PublicKey.deserialize_from_protobuf()
      • PublicKey.serialize()
      • PublicKey.verify()
  • libp2p.crypto.rsa module
    • RSAPrivateKey
      • RSAPrivateKey.get_public_key()
      • RSAPrivateKey.get_type()
      • RSAPrivateKey.new()
      • RSAPrivateKey.sign()
      • RSAPrivateKey.to_bytes()
    • RSAPublicKey
      • RSAPublicKey.from_bytes()
      • RSAPublicKey.get_type()
      • RSAPublicKey.to_bytes()
      • RSAPublicKey.verify()
    • create_new_key_pair()
  • libp2p.crypto.secp256k1 module
    • Secp256k1PrivateKey
      • Secp256k1PrivateKey.deserialize()
      • Secp256k1PrivateKey.from_bytes()
      • Secp256k1PrivateKey.get_public_key()
      • Secp256k1PrivateKey.get_type()
      • Secp256k1PrivateKey.new()
      • Secp256k1PrivateKey.sign()
      • Secp256k1PrivateKey.to_bytes()
    • Secp256k1PublicKey
      • Secp256k1PublicKey.deserialize()
      • Secp256k1PublicKey.from_bytes()
      • Secp256k1PublicKey.get_type()
      • Secp256k1PublicKey.to_bytes()
      • Secp256k1PublicKey.verify()
    • create_new_key_pair()
  • libp2p.crypto.serialization module
    • deserialize_private_key()
    • deserialize_public_key()
  • Module contents
• libp2p.host package
  • Submodules
  • libp2p.host.basic_host module
    • BasicHost
      • BasicHost.close()
      • BasicHost.connect()
      • BasicHost.disconnect()
      • BasicHost.get_addrs()
      • BasicHost.get_id()
      • BasicHost.get_mux()
      • BasicHost.get_network()
      • BasicHost.get_peerstore()
      • BasicHost.get_private_key()
      • BasicHost.get_public_key()
      • BasicHost.multiselect
      • BasicHost.multiselect_client
      • BasicHost.new_stream()
      • BasicHost.peerstore
      • BasicHost.run()
      • BasicHost.set_stream_handler()
  • libp2p.host.defaults module
    • get_default_protocols()
  • libp2p.host.exceptions module
    • ConnectionFailure
    • HostException
    • StreamFailure
  • libp2p.host.host_interface module
    • IHost
      • IHost.close()
      • IHost.connect()
      • IHost.disconnect()
      • IHost.get_addrs()
      • IHost.get_id()
      • IHost.get_mux()
      • IHost.get_network()
      • IHost.get_private_key()
      • IHost.get_public_key()
      • IHost.new_stream()
      • IHost.run()
      • IHost.set_stream_handler()
  • libp2p.host.ping module
    • handle_ping()
  • libp2p.host.routed_host module
    • RoutedHost
      • RoutedHost.connect()
  • Module contents
• libp2p.identity package
  • Subpackages
    • libp2p.identity.identify package
      • Subpackages
      • Submodules
      • libp2p.identity.identify.protocol module
      • Module contents
  • Module contents
• libp2p.io package
  • Submodules
  • libp2p.io.abc module
    • Closer
      • Closer.close()
    • EncryptedMsgReadWriter
    • Encrypter
      • Encrypter.decrypt()
      • Encrypter.encrypt()
    • MsgReadWriteCloser
    • MsgReader
      • MsgReader.read_msg()
    • MsgWriter
      • MsgWriter.write_msg()
    • ReadCloser
    • ReadWriteCloser
    • ReadWriter
    • Reader
      • Reader.read()
    • WriteCloser
    • Writer
      • Writer.write()
  • libp2p.io.exceptions module
    • DecryptionFailedException
    • IOException
    • IncompleteReadError
    • MessageTooLarge
    • MissingLengthException
    • MissingMessageException
    • MsgioException
  • libp2p.io.msgio module
    • BaseMsgReadWriter
      • BaseMsgReadWriter.close()
      • BaseMsgReadWriter.encode_msg()
      • BaseMsgReadWriter.next_msg_len()
      • BaseMsgReadWriter.read_msg()
      • BaseMsgReadWriter.read_write_closer
      • BaseMsgReadWriter.size_len_bytes
      • BaseMsgReadWriter.write_msg()
    • FixedSizeLenMsgReadWriter
      • FixedSizeLenMsgReadWriter.encode_msg()
      • FixedSizeLenMsgReadWriter.next_msg_len()
      • FixedSizeLenMsgReadWriter.size_len_bytes
    • VarIntLengthMsgReadWriter
      • VarIntLengthMsgReadWriter.encode_msg()
      • VarIntLengthMsgReadWriter.max_msg_size
      • VarIntLengthMsgReadWriter.next_msg_len()
    • encode_msg_with_length()
    • read_length()
  • libp2p.io.trio module
    • TrioTCPStream
      • TrioTCPStream.close()
      • TrioTCPStream.read()
      • TrioTCPStream.read_lock
      • TrioTCPStream.stream
      • TrioTCPStream.write()
      • TrioTCPStream.write_lock
  • libp2p.io.utils module
    • read_exactly()
  • Module contents
• libp2p.network package
  • Subpackages
    • libp2p.network.connection package
      • Submodules
      • libp2p.network.connection.exceptions module
      • libp2p.network.connection.net_connection_interface module
      • libp2p.network.connection.raw_connection module
      • libp2p.network.connection.raw_connection_interface module
      • libp2p.network.connection.swarm_connection module
      • Module contents
    • libp2p.network.stream package
      • Submodules
      • libp2p.network.stream.exceptions module
      • libp2p.network.stream.net_stream module
      • libp2p.network.stream.net_stream_interface module
      • Module contents
  • Submodules
  • libp2p.network.exceptions module
    • SwarmException
  • libp2p.network.network_interface module
    • INetwork
      • INetwork.close()
      • INetwork.close_peer()
      • INetwork.connections
      • INetwork.dial_peer()
      • INetwork.get_peer_id()
      • INetwork.listen()
      • INetwork.listeners
      • INetwork.new_stream()
      • INetwork.peerstore
      • INetwork.register_notifee()
      • INetwork.set_stream_handler()
    • INetworkService
  • libp2p.network.notifee_interface module
    • INotifee
      • INotifee.closed_stream()
      • INotifee.connected()
      • INotifee.disconnected()
      • INotifee.listen()
      • INotifee.listen_close()
      • INotifee.opened_stream()
  • libp2p.network.swarm module
    • Swarm
      • Swarm.add_conn()
      • Swarm.close()
      • Swarm.close_peer()
      • Swarm.common_stream_handler
      • Swarm.connections
      • Swarm.dial_addr()
      • Swarm.dial_peer()
      • Swarm.event_listener_nursery_created
      • Swarm.get_peer_id()
      • Swarm.listen()
      • Swarm.listener_nursery
      • Swarm.listeners
      • Swarm.new_stream()
      • Swarm.notifees
      • Swarm.notify_closed_stream()
      • Swarm.notify_connected()
      • Swarm.notify_disconnected()
      • Swarm.notify_listen()
      • Swarm.notify_listen_close()
      • Swarm.notify_opened_stream()
      • Swarm.peerstore
      • Swarm.register_notifee()
      • Swarm.remove_conn()
      • Swarm.run()
      • Swarm.self_id
      • Swarm.set_stream_handler()
      • Swarm.transport
      • Swarm.upgrader
    • create_default_stream_handler()
  • Module contents
• libp2p.peer package
  • Submodules
  • libp2p.peer.addrbook_interface module
    • IAddrBook
      • IAddrBook.add_addr()
      • IAddrBook.add_addrs()
      • IAddrBook.addrs()
      • IAddrBook.clear_addrs()
      • IAddrBook.peers_with_addrs()
  • libp2p.peer.id module
    • ID
      • ID.from_base58()
      • ID.from_pubkey()
      • ID.pretty()
      • ID.to_base58()
      • ID.to_bytes()
      • ID.to_string()
      • ID.xor_id
    • IdentityHash
      • IdentityHash.digest()
      • IdentityHash.update()
    • sha256_digest()
  • libp2p.peer.peerdata module
    • PeerData
      • PeerData.add_addrs()
      • PeerData.add_privkey()
      • PeerData.add_protocols()
      • PeerData.add_pubkey()
      • PeerData.addrs
      • PeerData.clear_addrs()
      • PeerData.get_addrs()
      • PeerData.get_metadata()
      • PeerData.get_privkey()
      • PeerData.get_protocols()
      • PeerData.get_pubkey()
      • PeerData.metadata
      • PeerData.privkey
      • PeerData.protocols
      • PeerData.pubkey
      • PeerData.put_metadata()
      • PeerData.set_protocols()
    • PeerDataError
  • libp2p.peer.peerdata_interface module
    • IPeerData
      • IPeerData.add_addrs()
      • IPeerData.add_privkey()
      • IPeerData.add_protocols()
      • IPeerData.add_pubkey()
      • IPeerData.clear_addrs()
      • IPeerData.get_addrs()
      • IPeerData.get_metadata()
      • IPeerData.get_privkey()
      • IPeerData.get_protocols()
      • IPeerData.get_pubkey()
      • IPeerData.put_metadata()
      • IPeerData.set_protocols()
  • libp2p.peer.peerinfo module
    • InvalidAddrError
    • PeerInfo
      • PeerInfo.addrs
      • PeerInfo.peer_id
    • info_from_p2p_addr()
  • libp2p.peer.peermetadata_interface module
    • IPeerMetadata
      • IPeerMetadata.get()
      • IPeerMetadata.put()
  • libp2p.peer.peerstore module
    • PeerStore
      • PeerStore.add_addr()
      • PeerStore.add_addrs()
      • PeerStore.add_key_pair()
      • PeerStore.add_privkey()
      • PeerStore.add_protocols()
      • PeerStore.add_pubkey()
      • PeerStore.addrs()
      • PeerStore.clear_addrs()
      • PeerStore.get()
      • PeerStore.get_protocols()
      • PeerStore.peer_data_map
      • PeerStore.peer_ids()
      • PeerStore.peer_info()
      • PeerStore.peers_with_addrs()
      • PeerStore.privkey()
      • PeerStore.pubkey()
      • PeerStore.put()
      • PeerStore.set_protocols()
    • PeerStoreError
  • libp2p.peer.peerstore_interface module
    • IPeerStore
      • IPeerStore.add_addr()
      • IPeerStore.add_addrs()
      • IPeerStore.add_key_pair()
      • IPeerStore.add_privkey()
      • IPeerStore.add_protocols()
      • IPeerStore.add_pubkey()
      • IPeerStore.addrs()
      • IPeerStore.clear_addrs()
      • IPeerStore.get()
      • IPeerStore.get_protocols()
      • IPeerStore.peer_ids()
      • IPeerStore.peer_info()
      • IPeerStore.peers_with_addrs()
      • IPeerStore.privkey()
      • IPeerStore.pubkey()
      • IPeerStore.put()
      • IPeerStore.set_protocols()
  • Module contents
• libp2p.protocol_muxer package
  • Submodules
  • libp2p.protocol_muxer.exceptions module
    • MultiselectClientError
    • MultiselectCommunicatorError
    • MultiselectError
  • libp2p.protocol_muxer.multiselect module
    • Multiselect
      • Multiselect.add_handler()
      • Multiselect.handlers
      • Multiselect.handshake()
      • Multiselect.negotiate()
    • is_valid_handshake()
  • libp2p.protocol_muxer.multiselect_client module
    • MultiselectClient
      • MultiselectClient.handshake()
      • MultiselectClient.select_one_of()
      • MultiselectClient.try_select()
    • is_valid_handshake()
  • libp2p.protocol_muxer.multiselect_client_interface module
    • IMultiselectClient
      • IMultiselectClient.handshake()
      • IMultiselectClient.select_one_of()
      • IMultiselectClient.try_select()
  • libp2p.protocol_muxer.multiselect_communicator module
    • MultiselectCommunicator
      • MultiselectCommunicator.read()
      • MultiselectCommunicator.read_writer
      • MultiselectCommunicator.write()
  • libp2p.protocol_muxer.multiselect_communicator_interface module
    • IMultiselectCommunicator
      • IMultiselectCommunicator.read()
      • IMultiselectCommunicator.write()
  • libp2p.protocol_muxer.multiselect_muxer_interface module
    • IMultiselectMuxer
      • IMultiselectMuxer.add_handler()
      • IMultiselectMuxer.get_protocols()
      • IMultiselectMuxer.handlers
      • IMultiselectMuxer.negotiate()
  • Module contents
• libp2p.pubsub package
  • Subpackages
    • libp2p.pubsub.pb package
      • Submodules
      • libp2p.pubsub.pb.rpc_pb2 module
      • Module contents
  • Submodules
  • libp2p.pubsub.abc module
    • IPubsub
      • IPubsub.my_id
      • IPubsub.protocols
      • IPubsub.publish()
      • IPubsub.remove_topic_validator()
      • IPubsub.set_topic_validator()
      • IPubsub.subscribe()
      • IPubsub.topic_ids
      • IPubsub.unsubscribe()
      • IPubsub.wait_until_ready()
    • IPubsubRouter
      • IPubsubRouter.add_peer()
      • IPubsubRouter.attach()
      • IPubsubRouter.get_protocols()
      • IPubsubRouter.handle_rpc()
      • IPubsubRouter.join()
      • IPubsubRouter.leave()
      • IPubsubRouter.publish()
      • IPubsubRouter.remove_peer()
    • ISubscriptionAPI
      • ISubscriptionAPI.get()
      • ISubscriptionAPI.unsubscribe()
  • libp2p.pubsub.exceptions module
    • NoPubsubAttached
    • PubsubRouterError
  • libp2p.pubsub.floodsub module
    • FloodSub
      • FloodSub.add_peer()
      • FloodSub.attach()
      • FloodSub.get_protocols()
      • FloodSub.handle_rpc()
      • FloodSub.join()
      • FloodSub.leave()
      • FloodSub.protocols
      • FloodSub.publish()
      • FloodSub.pubsub
      • FloodSub.remove_peer()
  • libp2p.pubsub.gossipsub module
    • GossipSub
      • GossipSub.add_peer()
      • GossipSub.attach()
      • GossipSub.degree
      • GossipSub.degree_high
      • GossipSub.degree_low
      • GossipSub.emit_control_message()
      • GossipSub.emit_graft()
      • GossipSub.emit_ihave()
      • GossipSub.emit_iwant()
      • GossipSub.emit_prune()
      • GossipSub.fanout
      • GossipSub.fanout_heartbeat()
      • GossipSub.get_protocols()
      • GossipSub.gossip_heartbeat()
      • GossipSub.handle_graft()
      • GossipSub.handle_ihave()
      • GossipSub.handle_iwant()
      • GossipSub.handle_prune()
      • GossipSub.handle_rpc()
      • GossipSub.heartbeat()
      • GossipSub.heartbeat_initial_delay
      • GossipSub.heartbeat_interval
      • GossipSub.join()
      • GossipSub.leave()
      • GossipSub.mcache
      • GossipSub.mesh
      • GossipSub.mesh_heartbeat()
      • GossipSub.pack_control_msgs()
      • GossipSub.peer_protocol
      • GossipSub.protocols
      • GossipSub.publish()
      • GossipSub.pubsub
      • GossipSub.remove_peer()
      • GossipSub.run()
      • GossipSub.select_from_minus()
      • GossipSub.time_to_live
  • libp2p.pubsub.mcache module
    • CacheEntry
      • CacheEntry.mid
      • CacheEntry.topics
    • MessageCache
      • MessageCache.get()
      • MessageCache.history
      • MessageCache.history_size
      • MessageCache.msgs
      • MessageCache.put()
      • MessageCache.shift()
      • MessageCache.window()
      • MessageCache.window_size
  • libp2p.pubsub.pubsub module
    • Pubsub
      • Pubsub.continuously_read_stream()
      • Pubsub.counter
      • Pubsub.dead_peer_receive_channel
      • Pubsub.event_handle_dead_peer_queue_started
      • Pubsub.event_handle_peer_queue_started
      • Pubsub.get_hello_packet()
      • Pubsub.get_msg_validators()
      • Pubsub.handle_dead_peer_queue()
      • Pubsub.handle_peer_queue()
      • Pubsub.handle_subscription()
      • Pubsub.host
      • Pubsub.message_all_peers()
      • Pubsub.my_id
      • Pubsub.notify_subscriptions()
      • Pubsub.peer_receive_channel
      • Pubsub.peer_topics
      • Pubsub.peers
      • Pubsub.protocols
      • Pubsub.publish()
      • Pubsub.push_msg()
      • Pubsub.remove_topic_validator()
      • Pubsub.router
      • Pubsub.run()
      • Pubsub.seen_messages
      • Pubsub.set_topic_validator()
      • Pubsub.sign_key
      • Pubsub.stream_handler()
      • Pubsub.strict_signing
      • Pubsub.subscribe()
      • Pubsub.subscribed_topics_receive
      • Pubsub.subscribed_topics_send
      • Pubsub.topic_ids
      • Pubsub.topic_validators
      • Pubsub.unsubscribe()
      • Pubsub.validate_msg()
      • Pubsub.wait_until_ready()
    • TopicValidator
      • TopicValidator.is_async
      • TopicValidator.validator
    • get_content_addressed_msg_id()
    • get_peer_and_seqno_msg_id()
  • libp2p.pubsub.pubsub_notifee module
    • PubsubNotifee
      • PubsubNotifee.closed_stream()
      • PubsubNotifee.connected()
      • PubsubNotifee.dead_peers_queue
      • PubsubNotifee.disconnected()
      • PubsubNotifee.initiator_peers_queue
      • PubsubNotifee.listen()
      • PubsubNotifee.listen_close()
      • PubsubNotifee.opened_stream()
  • libp2p.pubsub.subscription module
    • BaseSubscriptionAPI
    • TrioSubscriptionAPI
      • TrioSubscriptionAPI.get()
      • TrioSubscriptionAPI.receive_channel
      • TrioSubscriptionAPI.unsubscribe()
      • TrioSubscriptionAPI.unsubscribe_fn
  • libp2p.pubsub.typing module
  • libp2p.pubsub.validators module
    • signature_validator()
  • Module contents
• libp2p.routing package
  • Submodules
  • libp2p.routing.interfaces module
    • IContentRouting
      • IContentRouting.find_provider_iter()
      • IContentRouting.provide()
    • IPeerRouting
      • IPeerRouting.find_peer()
  • Module contents
• libp2p.security package
  • Subpackages
    • libp2p.security.insecure package
      • Subpackages
      • Submodules
      • libp2p.security.insecure.transport module
      • Module contents
    • libp2p.security.noise package
      • Subpackages
      • Submodules
      • libp2p.security.noise.exceptions module
      • libp2p.security.noise.io module
      • libp2p.security.noise.messages module
      • libp2p.security.noise.patterns module
      • libp2p.security.noise.transport module
      • Module contents
    • libp2p.security.secio package
      • Subpackages
      • Submodules
      • libp2p.security.secio.exceptions module
      • libp2p.security.secio.transport module
      • Module contents
  • Submodules
  • libp2p.security.base_session module
    • BaseSession
      • BaseSession.get_local_peer()
      • BaseSession.get_local_private_key()
      • BaseSession.get_remote_peer()
      • BaseSession.get_remote_public_key()
      • BaseSession.local_peer
      • BaseSession.local_private_key
      • BaseSession.remote_peer
      • BaseSession.remote_permanent_pubkey
  • libp2p.security.base_transport module
    • BaseSecureTransport
    • default_secure_bytes_provider()
  • libp2p.security.exceptions module
    • HandshakeFailure
  • libp2p.security.secure_conn_interface module
    • AbstractSecureConn
      • AbstractSecureConn.get_local_peer()
      • AbstractSecureConn.get_local_private_key()
      • AbstractSecureConn.get_remote_peer()
      • AbstractSecureConn.get_remote_public_key()
    • ISecureConn
  • libp2p.security.secure_session module
    • SecureSession
      • SecureSession.buf
      • SecureSession.close()
      • SecureSession.high_watermark
      • SecureSession.low_watermark
      • SecureSession.read()
      • SecureSession.write()
  • libp2p.security.secure_transport_interface module
    • ISecureTransport
      • ISecureTransport.secure_inbound()
      • ISecureTransport.secure_outbound()
  • libp2p.security.security_multistream module
    • SecurityMultistream
      • SecurityMultistream.add_transport()
      • SecurityMultistream.multiselect
      • SecurityMultistream.multiselect_client
      • SecurityMultistream.secure_inbound()
      • SecurityMultistream.secure_outbound()
      • SecurityMultistream.select_transport()
      • SecurityMultistream.transports
  • Module contents
• libp2p.stream_muxer package
  • Subpackages
    • libp2p.stream_muxer.mplex package
      • Submodules
      • libp2p.stream_muxer.mplex.constants module
      • libp2p.stream_muxer.mplex.datastructures module
      • libp2p.stream_muxer.mplex.exceptions module
      • libp2p.stream_muxer.mplex.mplex module
      • libp2p.stream_muxer.mplex.mplex_stream module
      • Module contents
  • Submodules
  • libp2p.stream_muxer.abc module
    • IMuxedConn
      • IMuxedConn.accept_stream()
      • IMuxedConn.close()
      • IMuxedConn.event_started
      • IMuxedConn.is_closed
      • IMuxedConn.is_initiator
      • IMuxedConn.open_stream()
      • IMuxedConn.peer_id
      • IMuxedConn.start()
    • IMuxedStream
      • IMuxedStream.muxed_conn
      • IMuxedStream.reset()
      • IMuxedStream.set_deadline()
  • libp2p.stream_muxer.exceptions module
    • MuxedConnError
    • MuxedConnUnavailable
    • MuxedStreamClosed
    • MuxedStreamEOF
    • MuxedStreamError
    • MuxedStreamReset
  • libp2p.stream_muxer.muxer_multistream module
    • MuxerMultistream
      • MuxerMultistream.add_transport()
      • MuxerMultistream.multiselect
      • MuxerMultistream.multiselect_client
      • MuxerMultistream.new_conn()
      • MuxerMultistream.select_transport()
      • MuxerMultistream.transports
  • Module contents
• libp2p.tools package
  • Subpackages
    • libp2p.tools.pubsub package
      • Submodules
      • libp2p.tools.pubsub.dummy_account_node module
      • libp2p.tools.pubsub.floodsub_integration_test_settings module
      • libp2p.tools.pubsub.utils module
      • Module contents
  • Submodules
  • libp2p.tools.constants module
    • GossipsubParams
      • GossipsubParams.degree
      • GossipsubParams.degree_high
      • GossipsubParams.degree_low
      • GossipsubParams.gossip_history
      • GossipsubParams.gossip_window
      • GossipsubParams.heartbeat_initial_delay
      • GossipsubParams.heartbeat_interval
      • GossipsubParams.time_to_live
  • libp2p.tools.factories module
    • DummyRouter
      • DummyRouter.find_peer()
    • FloodsubFactory
      • FloodsubFactory.protocols
    • GossipsubFactory
      • GossipsubFactory.degree
      • GossipsubFactory.degree_high
      • GossipsubFactory.degree_low
      • GossipsubFactory.gossip_history
      • GossipsubFactory.gossip_window
      • GossipsubFactory.heartbeat_initial_delay
      • GossipsubFactory.heartbeat_interval
      • GossipsubFactory.protocols
      • GossipsubFactory.time_to_live
    • HostFactory
      • HostFactory.create_batch_and_listen()
      • HostFactory.network
    • IDFactory
      • IDFactory.peer_id_bytes
    • PubsubFactory
      • PubsubFactory.cache_size
      • PubsubFactory.create_and_start()
      • PubsubFactory.create_batch_with_floodsub()
      • PubsubFactory.create_batch_with_gossipsub()
      • PubsubFactory.host
      • PubsubFactory.router
      • PubsubFactory.strict_signing
    • RoutedHostFactory
      • RoutedHostFactory.create_batch_and_listen()
      • RoutedHostFactory.network
      • RoutedHostFactory.router
    • SwarmFactory
      • SwarmFactory.create_and_listen()
      • SwarmFactory.create_batch_and_listen()
      • SwarmFactory.peer_id
      • SwarmFactory.peerstore
      • SwarmFactory.transport
      • SwarmFactory.upgrader
    • default_key_pair_factory()
    • default_muxer_transport_factory()
    • host_pair_factory()
    • initialize_peerstore_with_our_keypair()
    • mplex_conn_pair_factory()
    • mplex_stream_pair_factory()
    • mplex_transport_factory()
    • net_stream_pair_factory()
    • noise_conn_factory()
    • noise_handshake_payload_factory()
    • noise_static_key_factory()
    • noise_transport_factory()
    • plaintext_transport_factory()
    • raw_conn_factory()
    • secio_transport_factory()
    • security_options_factory_factory()
    • swarm_conn_pair_factory()
    • swarm_pair_factory()
  • libp2p.tools.utils module
    • connect()
    • connect_swarm()
    • create_echo_stream_handler()
  • Module contents
• libp2p.transport package
  • Subpackages
    • libp2p.transport.tcp package
      • Submodules
      • libp2p.transport.tcp.tcp module
      • Module contents
  • Submodules
  • libp2p.transport.exceptions module
    • MuxerUpgradeFailure
    • OpenConnectionError
    • SecurityUpgradeFailure
    • UpgradeFailure
  • libp2p.transport.listener_interface module
    • IListener
      • IListener.close()
      • IListener.get_addrs()
      • IListener.listen()
  • libp2p.transport.transport_interface module
    • ITransport
      • ITransport.create_listener()
      • ITransport.dial()
  • libp2p.transport.typing module
  • libp2p.transport.upgrader module
    • TransportUpgrader
      • TransportUpgrader.muxer_multistream
      • TransportUpgrader.security_multistream
      • TransportUpgrader.upgrade_connection()
      • TransportUpgrader.upgrade_listener()
      • TransportUpgrader.upgrade_security()
  • Module contents

Submodules

libp2p.exceptions module

exception libp2p.exceptions.BaseLibp2pError

Bases: Exception

exception libp2p.exceptions.MultiError

Bases: BaseLibp2pError

Raised with multiple exceptions.

exception libp2p.exceptions.ParseError

Bases: BaseLibp2pError

exception libp2p.exceptions.ValidationError

Bases: BaseLibp2pError

Raised when something does not pass a validation check.

libp2p.typing module

libp2p.utils module

async libp2p.utils.decode_uvarint_from_stream(reader: Reader) → int

https://en.wikipedia.org/wiki/LEB128.

libp2p.utils.encode_delim(msg: bytes) → bytes

libp2p.utils.encode_uvarint(number: int) → bytes

Pack number into varint bytes.

libp2p.utils.encode_varint_prefixed(msg_bytes: bytes) → bytes

async libp2p.utils.read_delim(reader: Reader) → bytes

async libp2p.utils.read_varint_prefixed_bytes(reader: Reader) → bytes

Module contents

libp2p.generate_new_rsa_identity() → KeyPair

libp2p.generate_peer_id_from(key_pair: KeyPair) → ID

libp2p.new_host(key_pair: KeyPair | None = None, muxer_opt: Mapping[TProtocol, Type[IMuxedConn]] | None = None, sec_opt: Mapping[TProtocol, ISecureTransport] | None = None, peerstore_opt: IPeerStore | None = None, disc_opt: IPeerRouting | None = None) → IHost

Create a new libp2p host based on the given parameters.

Parameters:

• key_pair – optional choice of the KeyPair

• muxer_opt – optional choice of stream muxer

• sec_opt – optional choice of security upgrade

• peerstore_opt – optional peerstore

• disc_opt – optional discovery

Returns:

return a host instance

libp2p.new_swarm(key_pair: KeyPair | None = None, muxer_opt: Mapping[TProtocol, Type[IMuxedConn]] | None = None, sec_opt: Mapping[TProtocol, ISecureTransport] | None = None, peerstore_opt: IPeerStore | None = None) → INetworkService

Create a swarm instance based on the parameters.

Parameters:

• key_pair – optional choice of the KeyPair

• muxer_opt – optional choice of stream muxer

• sec_opt – optional choice of security upgrade

• peerstore_opt – optional peerstore

Returns:

return a default swarm instance