libp2p 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libp2p
-Version: 0.2.5
+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
@@ -27,11 +27,12 @@ License-File: LICENSE-APACHE
 Requires-Dist: base58>=1.0.3
 Requires-Dist: coincurve>=10.0.0
 Requires-Dist: exceptiongroup>=1.2.0; python_version < "3.11"
+Requires-Dist: grpcio>=1.41.0
 Requires-Dist: lru-dict>=1.1.6
 Requires-Dist: multiaddr>=0.0.9
 Requires-Dist: mypy-protobuf>=3.0.0
 Requires-Dist: noiseprotocol>=0.3.0
-Requires-Dist: protobuf>=5.27.0
+Requires-Dist: protobuf>=6.30.1
 Requires-Dist: pycryptodome>=3.9.2
 Requires-Dist: pymultihash>=0.8.2
 Requires-Dist: pynacl>=1.3.0

libp2p-0.2.7/examples/identify_push/identify_push_demo.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Example demonstrating the identify/push protocol.
+
+This example shows how to:
+1. Set up a host with the identify/push protocol handler
+2. Connect to another peer
+3. Push identify information to the peer
+4. Receive and process identify/push messages
+"""
+
+import logging
+
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.crypto.secp256k1 import (
+    create_new_key_pair,
+)
+from libp2p.custom_types import (
+    TProtocol,
+)
+from libp2p.identity.identify import (
+    identify_handler_for,
+)
+from libp2p.identity.identify_push import (
+    ID_PUSH,
+    identify_push_handler_for,
+    push_identify_to_peer,
+)
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+async def main() -> None:
+    print("\n==== Starting Identify-Push Example ====\n")
+
+    # Create key pairs for the two hosts
+    key_pair_1 = create_new_key_pair()
+    key_pair_2 = create_new_key_pair()
+
+    # Create the first host
+    host_1 = new_host(key_pair=key_pair_1)
+
+    # Set up the identify and identify/push handlers
+    host_1.set_stream_handler(TProtocol("/ipfs/id/1.0.0"), identify_handler_for(host_1))
+    host_1.set_stream_handler(ID_PUSH, identify_push_handler_for(host_1))
+
+    # Create the second host
+    host_2 = new_host(key_pair=key_pair_2)
+
+    # Set up the identify and identify/push handlers
+    host_2.set_stream_handler(TProtocol("/ipfs/id/1.0.0"), identify_handler_for(host_2))
+    host_2.set_stream_handler(ID_PUSH, identify_push_handler_for(host_2))
+
+    # Start listening on random ports using the run context manager
+    import multiaddr
+
+    listen_addr_1 = multiaddr.Multiaddr("/ip4/127.0.0.1/tcp/0")
+    listen_addr_2 = multiaddr.Multiaddr("/ip4/127.0.0.1/tcp/0")
+
+    async with host_1.run([listen_addr_1]), host_2.run([listen_addr_2]):
+        # Get the addresses of both hosts
+        addr_1 = host_1.get_addrs()[0]
+        logger.info(f"Host 1 listening on {addr_1}")
+        print(f"Host 1 listening on {addr_1}")
+        print(f"Peer ID: {host_1.get_id().pretty()}")
+
+        addr_2 = host_2.get_addrs()[0]
+        logger.info(f"Host 2 listening on {addr_2}")
+        print(f"Host 2 listening on {addr_2}")
+        print(f"Peer ID: {host_2.get_id().pretty()}")
+
+        print("\nConnecting Host 2 to Host 1...")
+
+        # Connect host_2 to host_1
+        peer_info = info_from_p2p_addr(addr_1)
+        await host_2.connect(peer_info)
+        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...")
+
+        try:
+            # Call push_identify_to_peer which now returns a boolean
+            success = await push_identify_to_peer(host_1, host_2.get_id())
+
+            if success:
+                logger.info("Identify push completed successfully")
+                print("Identify push completed successfully!")
+            else:
+                logger.warning("Identify push didn't complete successfully")
+                print("\nWarning: Identify push didn't complete successfully")
+
+        except Exception as e:
+            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)
+
+
+def run_main():
+    """Non-async entry point for the console script."""
+    trio.run(main)

libp2p-0.2.7/examples/identify_push/identify_push_listener_dialer.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""
+Example demonstrating the identify/push protocol with separate listener and dialer
+roles.
+
+This example shows how to:
+1. Set up a listener host with the identify/push protocol handler
+2. Connect to the listener from a dialer peer
+3. Push identify information to the listener
+4. Receive and process identify/push messages
+
+Usage:
+    # First run this script as a listener (default port 8888):
+    python identify_push_listener_dialer.py
+
+    # Then in another console, run as a dialer (default port 8889):
+    python identify_push_listener_dialer.py -d /ip4/127.0.0.1/tcp/8888/p2p/PEER_ID
+    (where PEER_ID is the peer ID displayed by the listener)
+"""
+
+import argparse
+import logging
+import sys
+
+import multiaddr
+from multiaddr import (
+    Multiaddr,
+)
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.abc import (
+    INetStream,
+)
+from libp2p.crypto.secp256k1 import (
+    create_new_key_pair,
+)
+from libp2p.identity.identify import (
+    identify_handler_for,
+)
+from libp2p.identity.identify import ID as ID_IDENTIFY
+from libp2p.identity.identify.pb.identify_pb2 import (
+    Identify,
+)
+from libp2p.identity.identify_push import (
+    identify_push_handler_for,
+    push_identify_to_peer,
+)
+from libp2p.identity.identify_push import ID_PUSH as ID_IDENTIFY_PUSH
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+
+# Configure logging
+logger = logging.getLogger("libp2p.identity.identify-push-example")
+
+# Default port configuration
+DEFAULT_PORT = 8888
+
+
+def custom_identify_push_handler_for(host):
+    """
+    Create a custom handler for the identify/push protocol that logs and prints
+    the identity information received from the dialer.
+    """
+
+    async def handle_identify_push(stream: INetStream) -> None:
+        peer_id = stream.muxed_conn.peer_id
+
+        try:
+            # Read the identify message from the stream
+            data = await stream.read()
+            identify_msg = Identify()
+            identify_msg.ParseFromString(data)
+
+            # Log and print the identify information
+            logger.info("Received identify/push from peer %s", peer_id)
+            print(f"\n==== Received identify/push from peer {peer_id} ====")
+
+            if identify_msg.HasField("protocol_version"):
+                logger.info("  Protocol Version: %s", identify_msg.protocol_version)
+                print(f"  Protocol Version: {identify_msg.protocol_version}")
+
+            if identify_msg.HasField("agent_version"):
+                logger.info("  Agent Version: %s", identify_msg.agent_version)
+                print(f"  Agent Version: {identify_msg.agent_version}")
+
+            if identify_msg.HasField("public_key"):
+                logger.info(
+                    "  Public Key: %s", identify_msg.public_key.hex()[:16] + "..."
+                )
+                print(f"  Public Key: {identify_msg.public_key.hex()[:16]}...")
+
+            if identify_msg.listen_addrs:
+                addrs = [Multiaddr(addr) for addr in identify_msg.listen_addrs]
+                logger.info("  Listen Addresses: %s", addrs)
+                print("  Listen Addresses:")
+                for addr in addrs:
+                    print(f"    - {addr}")
+
+            if identify_msg.HasField("observed_addr") and identify_msg.observed_addr:
+                observed_addr = Multiaddr(identify_msg.observed_addr)
+                logger.info("  Observed Address: %s", observed_addr)
+                print(f"  Observed Address: {observed_addr}")
+
+            if identify_msg.protocols:
+                logger.info("  Protocols: %s", identify_msg.protocols)
+                print("  Protocols:")
+                for protocol in identify_msg.protocols:
+                    print(f"    - {protocol}")
+
+            # Update the peerstore with the new information as usual
+            peerstore = host.get_peerstore()
+            from libp2p.identity.identify_push.identify_push import (
+                _update_peerstore_from_identify,
+            )
+
+            await _update_peerstore_from_identify(peerstore, peer_id, identify_msg)
+
+            logger.info("Successfully processed identify/push from peer %s", peer_id)
+            print(f"\nSuccessfully processed identify/push from peer {peer_id}")
+
+        except Exception as e:
+            logger.error("Error processing identify/push from %s: %s", peer_id, e)
+            print(f"\nError processing identify/push from {peer_id}: {e}")
+        finally:
+            # Close the stream after processing
+            await stream.close()
+
+    return handle_identify_push
+
+
+async def run_listener(port: int) -> None:
+    """Run a host in listener mode."""
+    print(f"\n==== Starting Identify-Push Listener on port {port} ====\n")
+
+    # Create key pair for the listener
+    key_pair = create_new_key_pair()
+
+    # Create the listener host
+    host = new_host(key_pair=key_pair)
+
+    # Set up the identify and identify/push handlers
+    host.set_stream_handler(ID_IDENTIFY, identify_handler_for(host))
+    host.set_stream_handler(ID_IDENTIFY_PUSH, custom_identify_push_handler_for(host))
+
+    # Start listening
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+
+    async with host.run([listen_addr]):
+        addr = host.get_addrs()[0]
+        logger.info("Listener host ready!")
+        print("Listener host ready!")
+
+        logger.info(f"Listening on: {addr}")
+        print(f"Listening on: {addr}")
+
+        logger.info(f"Peer ID: {host.get_id().pretty()}")
+        print(f"Peer ID: {host.get_id().pretty()}")
+
+        print("\nRun dialer with command:")
+        print(f"identify-push-listener-dialer-demo -d {addr}")
+        print("\nWaiting for incoming connections... (Ctrl+C to exit)")
+
+        # Keep running until interrupted
+        await trio.sleep_forever()
+
+
+async def run_dialer(port: int, destination: str) -> None:
+    """Run a host in dialer mode that connects to a listener."""
+    print(f"\n==== Starting Identify-Push Dialer on port {port} ====\n")
+
+    # Create key pair for the dialer
+    key_pair = create_new_key_pair()
+
+    # Create the dialer host
+    host = new_host(key_pair=key_pair)
+
+    # Set up the identify and identify/push handlers
+    host.set_stream_handler(ID_IDENTIFY, identify_handler_for(host))
+    host.set_stream_handler(ID_IDENTIFY_PUSH, identify_push_handler_for(host))
+
+    # Start listening on a different port
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+
+    async with host.run([listen_addr]):
+        logger.info("Dialer host ready!")
+        print("Dialer host ready!")
+
+        logger.info(f"Listening on: {host.get_addrs()[0]}")
+        print(f"Listening on: {host.get_addrs()[0]}")
+
+        # Parse the destination multiaddress and connect to the listener
+        maddr = multiaddr.Multiaddr(destination)
+        peer_info = info_from_p2p_addr(maddr)
+        logger.info(f"Connecting to peer: {peer_info.peer_id}")
+        print(f"\nConnecting to peer: {peer_info.peer_id}")
+
+        try:
+            await host.connect(peer_info)
+            logger.info("Successfully connected to listener!")
+            print("Successfully connected to listener!")
+
+            # Push identify information to the listener
+            logger.info("Pushing identify information to listener...")
+            print("\nPushing identify information to listener...")
+
+            try:
+                # Call push_identify_to_peer which returns a boolean
+                success = await push_identify_to_peer(host, peer_info.peer_id)
+
+                if success:
+                    logger.info("Identify push completed successfully!")
+                    print("Identify push completed successfully!")
+
+                    logger.info("Example completed successfully!")
+                    print("\nExample completed successfully!")
+                else:
+                    logger.warning("Identify push didn't complete successfully.")
+                    print("\nWarning: Identify push didn't complete successfully.")
+
+                    logger.warning("Example completed with warnings.")
+                    print("Example completed with warnings.")
+            except Exception as e:
+                logger.error(f"Error during identify push: {str(e)}")
+                print(f"\nError during identify push: {str(e)}")
+
+                logger.error("Example completed with errors.")
+                print("Example completed with errors.")
+                # Continue execution despite the push error
+
+        except Exception as e:
+            logger.error(f"Error during dialer operation: {str(e)}")
+            print(f"\nError during dialer operation: {str(e)}")
+            raise
+
+
+def main() -> None:
+    """Parse arguments and start the appropriate mode."""
+    description = """
+    This program demonstrates the libp2p identify/push protocol.
+    Without arguments, it runs as a listener on port 8888.
+    With -d parameter, it runs as a dialer on port 8889.
+    """
+
+    example = (
+        f"/ip4/127.0.0.1/tcp/{DEFAULT_PORT}/p2p/"
+        "QmQn4SwGkDZkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
+    )
+
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        help=(
+            f"port to listen on (default: {DEFAULT_PORT} for listener, "
+            f"{DEFAULT_PORT + 1} for dialer)"
+        ),
+    )
+    parser.add_argument(
+        "-d",
+        "--destination",
+        type=str,
+        help=f"destination multiaddr string, e.g. {example}",
+    )
+    args = parser.parse_args()
+
+    try:
+        if args.destination:
+            # Run in dialer mode with default port DEFAULT_PORT + 1 if not specified
+            port = args.port if args.port is not None else DEFAULT_PORT + 1
+            trio.run(run_dialer, port, args.destination)
+        else:
+            # Run in listener mode with default port DEFAULT_PORT if not specified
+            port = args.port if args.port is not None else DEFAULT_PORT
+            trio.run(run_listener, port)
+    except KeyboardInterrupt:
+        print("\nInterrupted by user")
+        logger.info("Interrupted by user")
+    except Exception as e:
+        print(f"\nError: {str(e)}")
+        logger.error("Error: %s", str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()